jank/LF8
2
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases 13 Wiki Activity

feat: Implement Update Project Route (SCRUM-11) (!28)
All checks were successful
Quality Check / Tests (push) Successful in 58s
Details
Quality Check / Checkstyle Main (push) Successful in 46s
Details
Build / Build and analyze (push) Successful in 1m58s
Details
Release / Release (push) Successful in 37s
Details

Browse Source 
Co-authored-by: Phan Huy Tran <p.tran@neusta.de>
Reviewed-on: #28
Reviewed-by: Jan Gleytenhoover <krisellp9@gmail.com>
Co-authored-by: Phan Huy Tran <ptran@noreply.localhost>
Co-committed-by: Phan Huy Tran <ptran@noreply.localhost>
This commit is contained in:
Phan Huy Tran 2024-10-02 08:52:19 +00:00 committed by Jan Gleytenhoover
parent cbb77cc1ca
commit 4eb7626c10
23 changed files with 1065 additions and 786 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

168
build.gradle.kts
View File

@ -1,85 +1,85 @@
plugins { plugins {
java java
id("org.springframework.boot") version "3.3.4" id("org.springframework.boot") version "3.3.4"
id("io.spring.dependency-management") version "1.1.6" id("io.spring.dependency-management") version "1.1.6"
id("checkstyle") id("checkstyle")
id("org.sonarqube") version "5.1.0.4882" id("org.sonarqube") version "5.1.0.4882"
id("jacoco") id("jacoco")
} }
tasks.jacocoTestReport { tasks.jacocoTestReport {
dependsOn(tasks.test) // Ensure tests are run before generating the report dependsOn(tasks.test) // Ensure tests are run before generating the report
reports { reports {
xml.required = true xml.required = true
csv.required = true csv.required = true
} }
} }
sonar { sonar {
properties { properties {
property("sonar.projectKey", "LF8") property("sonar.projectKey", "LF8")
property("sonar.projectName", "LF8") property("sonar.projectName", "LF8")
} }
} }
tasks.withType<Checkstyle> { tasks.withType<Checkstyle> {
reports { reports {
// Disable HTML report // Disable HTML report
html.required.set(false) html.required.set(false)
// Disable XML report // Disable XML report
xml.required.set(false) xml.required.set(false)
} }
} }
group = "de.szut" group = "de.szut"
version = "0.0.1-SNAPSHOT" version = "0.0.1-SNAPSHOT"
tasks.test { tasks.test {
useJUnitPlatform() useJUnitPlatform()
// Activate the 'test' profile for Spring during tests // Activate the 'test' profile for Spring during tests
systemProperty("spring.profiles.active", "test") systemProperty("spring.profiles.active", "test")
} }
java { java {
toolchain { toolchain {
languageVersion = JavaLanguageVersion.of(21) languageVersion = JavaLanguageVersion.of(21)
} }
} }
configurations { configurations {
compileOnly { compileOnly {
extendsFrom(configurations.annotationProcessor.get()) extendsFrom(configurations.annotationProcessor.get())
} }
} }
repositories { repositories {
mavenCentral() mavenCentral()
} }
val springDocVersion = "2.6.0" val springDocVersion = "2.6.0"
val oauth2Version = "3.3.4" val oauth2Version = "3.3.4"
dependencies { dependencies {
implementation("org.springframework.boot:spring-boot-starter-data-jpa") implementation("org.springframework.boot:spring-boot-starter-data-jpa")
implementation("org.springframework.boot:spring-boot-starter-web") implementation("org.springframework.boot:spring-boot-starter-web")
implementation("org.springframework.boot:spring-boot-starter-validation") implementation("org.springframework.boot:spring-boot-starter-validation")
implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:$springDocVersion") implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:$springDocVersion")
implementation("org.springframework.boot:spring-boot-starter-security") implementation("org.springframework.boot:spring-boot-starter-security")
implementation("org.springframework.boot:spring-boot-starter-oauth2-resource-server:$oauth2Version") implementation("org.springframework.boot:spring-boot-starter-oauth2-resource-server:$oauth2Version")
implementation("org.springframework.boot:spring-boot-starter-oauth2-client:$oauth2Version") implementation("org.springframework.boot:spring-boot-starter-oauth2-client:$oauth2Version")
testImplementation("com.h2database:h2") testImplementation("com.h2database:h2")
testImplementation("org.springframework.boot:spring-boot-starter-test") testImplementation("org.springframework.boot:spring-boot-starter-test")
compileOnly("org.projectlombok:lombok") compileOnly("org.projectlombok:lombok")
annotationProcessor("org.projectlombok:lombok") annotationProcessor("org.projectlombok:lombok")
testRuntimeOnly("org.junit.platform:junit-platform-launcher") testRuntimeOnly("org.junit.platform:junit-platform-launcher")
runtimeOnly("org.postgresql:postgresql") runtimeOnly("org.postgresql:postgresql")
} }
tasks.withType<Test> { tasks.withType<Test> {
useJUnitPlatform() useJUnitPlatform()
finalizedBy(tasks.jacocoTestReport) // Run JaCoCo report after tests finalizedBy(tasks.jacocoTestReport) // Run JaCoCo report after tests
} }

6
requests/getProject.http
View File

@ -1,3 +1,3 @@
### GET request to example server ### GET request to example server
GET http://localhost:8080/projects/2 GET http://localhost:8080/projects/1
Authorization: Bearer {{auth_token}} Authorization: Bearer {{auth_token}}

15
requests/updateProject.http Normal file
View File

@ -0,0 +1,15 @@
### GET request to example server
PUT http://localhost:8080/projects/1
Authorization: Bearer {{auth_token}}
Content-Type: application/json
{
"name": "newName",
"leading_employee": 2,
"employees": [],
"contractor": 9,
"contractor_name": "New Contractor name",
"comment": "new goal of project",
"start_date": "01.01.2010",
"planned_end_date": "01.01.2021"
}

154
src/main/java/de/szut/lf8_starter/config/OpenAPIConfiguration.java
View File

@ -1,77 +1,77 @@
package de.szut.lf8_starter.config; package de.szut.lf8_starter.config;
import io.swagger.v3.oas.models.Components; import io.swagger.v3.oas.models.Components;
import io.swagger.v3.oas.models.OpenAPI; import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Info; import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.security.SecurityRequirement; import io.swagger.v3.oas.models.security.SecurityRequirement;
import io.swagger.v3.oas.models.security.SecurityScheme; import io.swagger.v3.oas.models.security.SecurityScheme;
import io.swagger.v3.oas.models.servers.Server; import io.swagger.v3.oas.models.servers.Server;
import jakarta.servlet.ServletContext; import jakarta.servlet.ServletContext;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
@Configuration @Configuration
public class OpenAPIConfiguration { public class OpenAPIConfiguration {
private ServletContext context; private ServletContext context;
public OpenAPIConfiguration(ServletContext context) { public OpenAPIConfiguration(ServletContext context) {
this.context = context; this.context = context;
} }
@Bean @Bean
public OpenAPI springShopOpenAPI( public OpenAPI springShopOpenAPI(
// @Value("${info.app.version}") String appVersion, // @Value("${info.app.version}") String appVersion,
) { ) {
final String securitySchemeName = "bearerAuth"; final String securitySchemeName = "bearerAuth";
return new OpenAPI() return new OpenAPI()
.addServersItem(new Server().url(this.context.getContextPath())) .addServersItem(new Server().url(this.context.getContextPath()))
.info(new Info() .info(new Info()
.title("LF8 project starter") .title("LF8 project starter")
.description(""" .description("""
## Auth ## Auth
## Authentication ## Authentication
This Hello service uses JWTs to authenticate requests. You will receive a bearer token by making a POST-Request in IntelliJ on: This Hello service uses JWTs to authenticate requests. You will receive a bearer token by making a POST-Request in IntelliJ on:
``` ```
POST http://keycloak.szut.dev/auth/realms/szut/protocol/openid-connect/token POST http://keycloak.szut.dev/auth/realms/szut/protocol/openid-connect/token
Content-Type: application/x-www-form-urlencoded Content-Type: application/x-www-form-urlencoded
grant_type=password&client_id=employee-management-service&username=user&password=test grant_type=password&client_id=employee-management-service&username=user&password=test
``` ```
or by CURL: or by CURL:
``` ```
curl -X POST 'http://keycloak.szut.dev/auth/realms/szut/protocol/openid-connect/token' curl -X POST 'http://keycloak.szut.dev/auth/realms/szut/protocol/openid-connect/token'
--header 'Content-Type: application/x-www-form-urlencoded' --header 'Content-Type: application/x-www-form-urlencoded'
--data-urlencode 'grant_type=password' --data-urlencode 'grant_type=password'
--data-urlencode 'client_id=employee-management-service' --data-urlencode 'client_id=employee-management-service'
--data-urlencode 'username=user' --data-urlencode 'username=user'
--data-urlencode 'password=test' --data-urlencode 'password=test'
``` ```
To get a bearer-token in Postman, you have to follow the instructions in To get a bearer-token in Postman, you have to follow the instructions in
[Postman-Documentation](https://documenter.getpostman.com/view/7294517/SzmfZHnd). [Postman-Documentation](https://documenter.getpostman.com/view/7294517/SzmfZHnd).
""") """)
.version("0.1")) .version("0.1"))
.addSecurityItem(new SecurityRequirement().addList(securitySchemeName)) .addSecurityItem(new SecurityRequirement().addList(securitySchemeName))
.components( .components(
new Components() new Components()
.addSecuritySchemes(securitySchemeName, .addSecuritySchemes(securitySchemeName,
new SecurityScheme() new SecurityScheme()
.name(securitySchemeName) .name(securitySchemeName)
.type(SecurityScheme.Type.HTTP) .type(SecurityScheme.Type.HTTP)
.scheme("bearer") .scheme("bearer")
.bearerFormat("JWT") .bearerFormat("JWT")
) )
); );
} }
} }

66
src/main/java/de/szut/lf8_starter/config/SampleDataCreator.java
View File

@ -1,33 +1,33 @@
package de.szut.lf8_starter.config; package de.szut.lf8_starter.config;
import de.szut.lf8_starter.hello.HelloEntity; import de.szut.lf8_starter.hello.HelloEntity;
import de.szut.lf8_starter.hello.HelloRepository; import de.szut.lf8_starter.hello.HelloRepository;
import org.springframework.boot.ApplicationArguments; import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner; import org.springframework.boot.ApplicationRunner;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate; import org.springframework.web.client.RestTemplate;
@Component @Component
public class SampleDataCreator implements ApplicationRunner { public class SampleDataCreator implements ApplicationRunner {
private HelloRepository repository; private HelloRepository repository;
public SampleDataCreator(HelloRepository repository) { public SampleDataCreator(HelloRepository repository) {
this.repository = repository; this.repository = repository;
} }
public void run(ApplicationArguments args) { public void run(ApplicationArguments args) {
repository.save(new HelloEntity("Hallo Welt!")); repository.save(new HelloEntity("Hallo Welt!"));
repository.save(new HelloEntity("Schöner Tag heute")); repository.save(new HelloEntity("Schöner Tag heute"));
repository.save(new HelloEntity("FooBar")); repository.save(new HelloEntity("FooBar"));
} }
@Bean @Bean
public RestTemplate restTemplate() { public RestTemplate restTemplate() {
return new RestTemplate(); return new RestTemplate();
} }
} }

110
src/main/java/de/szut/lf8_starter/exceptionHandling/GlobalExceptionHandler.java
View File

@ -1,51 +1,59 @@
package de.szut.lf8_starter.exceptionHandling; package de.szut.lf8_starter.exceptionHandling;
import io.swagger.v3.oas.annotations.media.Content; import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.responses.ApiResponse; import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses; import io.swagger.v3.oas.annotations.responses.ApiResponses;
import jakarta.validation.ConstraintViolationException; import jakarta.validation.ConstraintViolationException;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.MethodArgumentNotValidException; import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.context.request.WebRequest; import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.WebRequest;
import java.util.Date;
import java.util.Date;
@ControllerAdvice
@ApiResponses(value = { @ControllerAdvice
@ApiResponse(responseCode = "500", description = "invalid JSON posted", @ApiResponses(value = {
content = @Content) @ApiResponse(responseCode = "500", description = "invalid JSON posted",
}) content = @Content)
public class GlobalExceptionHandler { })
public class GlobalExceptionHandler {
@ExceptionHandler(ResourceNotFoundException.class)
public ResponseEntity<ErrorDetails> handleHelloEntityNotFoundException(ResourceNotFoundException ex, WebRequest request) { @ExceptionHandler(ResourceNotFoundException.class)
ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getMessage(), request.getDescription(false)); public ResponseEntity<ErrorDetails> handleHelloEntityNotFoundException(ResourceNotFoundException ex, WebRequest request) {
return new ResponseEntity<>(errorDetails, HttpStatus.NOT_FOUND); ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getMessage(), request.getDescription(false));
} return new ResponseEntity<>(errorDetails, HttpStatus.NOT_FOUND);
}
@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorDetails> handleAllOtherExceptions(Exception ex, WebRequest request) { @ExceptionHandler(Exception.class)
ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getClass() + " " + ex.getMessage(), request.getDescription(false)); public ResponseEntity<ErrorDetails> handleAllOtherExceptions(Exception ex, WebRequest request) {
ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getClass() + " " + ex.getMessage(), request.getDescription(false));
return new ResponseEntity<>(errorDetails, HttpStatus.INTERNAL_SERVER_ERROR);
} return new ResponseEntity<>(errorDetails, HttpStatus.INTERNAL_SERVER_ERROR);
}
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<ErrorDetails> handleMethodArgumentNotValidException(MethodArgumentNotValidException ex, WebRequest request) { @ExceptionHandler(MethodArgumentNotValidException.class)
ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getMessage(), request.getDescription(false)); public ResponseEntity<ErrorDetails> handleMethodArgumentNotValidException(MethodArgumentNotValidException ex, WebRequest request) {
ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getMessage(), request.getDescription(false));
return new ResponseEntity<>(errorDetails, HttpStatus.BAD_REQUEST);
} return new ResponseEntity<>(errorDetails, HttpStatus.BAD_REQUEST);
}
@ExceptionHandler(ConstraintViolationException.class)
public ResponseEntity<ErrorDetails> handleConstraintViolationException(ConstraintViolationException ex, WebRequest request) { @ExceptionHandler(HttpMessageNotReadableException.class)
String errorMessage = ex.getConstraintViolations().stream().findFirst().get().getMessage(); public ResponseEntity<ErrorDetails> handleHttpMessageNotReadableException(HttpMessageNotReadableException ex, WebRequest request) {
ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getMessage(), request.getDescription(false));
ErrorDetails errorDetails = new ErrorDetails(new Date(), errorMessage, request.getDescription(false));
return new ResponseEntity<>(errorDetails, HttpStatus.BAD_REQUEST);
return new ResponseEntity<>(errorDetails, HttpStatus.BAD_REQUEST); }
}
} @ExceptionHandler(ConstraintViolationException.class)
public ResponseEntity<ErrorDetails> handleConstraintViolationException(ConstraintViolationException ex, WebRequest request) {
String errorMessage = ex.getConstraintViolations().stream().findFirst().get().getMessage();
ErrorDetails errorDetails = new ErrorDetails(new Date(), errorMessage, request.getDescription(false));
return new ResponseEntity<>(errorDetails, HttpStatus.BAD_REQUEST);
}
}

130
src/main/java/de/szut/lf8_starter/hello/HelloController.java
View File

@ -1,65 +1,65 @@
package de.szut.lf8_starter.hello; package de.szut.lf8_starter.hello;
import de.szut.lf8_starter.exceptionHandling.ResourceNotFoundException; import de.szut.lf8_starter.exceptionHandling.ResourceNotFoundException;
import de.szut.lf8_starter.hello.dto.HelloCreateDto; import de.szut.lf8_starter.hello.dto.HelloCreateDto;
import de.szut.lf8_starter.hello.dto.HelloGetDto; import de.szut.lf8_starter.hello.dto.HelloGetDto;
import io.swagger.v3.oas.annotations.Operation; import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content; import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse; import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses; import io.swagger.v3.oas.annotations.responses.ApiResponses;
import jakarta.validation.Valid; import jakarta.validation.Valid;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.security.access.prepost.PreAuthorize; import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import java.util.List; import java.util.List;
import java.util.stream.Collectors; import java.util.stream.Collectors;
@RestController @RestController
@RequestMapping(value = "hello") @RequestMapping(value = "hello")
@PreAuthorize("hasAnyAuthority('user')") @PreAuthorize("hasAnyAuthority('user')")
public class HelloController { public class HelloController {
private final HelloService service; private final HelloService service;
private final HelloMapper helloMapper; private final HelloMapper helloMapper;
public HelloController(HelloService service, HelloMapper mappingService) { public HelloController(HelloService service, HelloMapper mappingService) {
this.service = service; this.service = service;
this.helloMapper = mappingService; this.helloMapper = mappingService;
} }
@Operation(summary = "creates a new hello with its id and message") @Operation(summary = "creates a new hello with its id and message")
@ApiResponses(value = { @ApiResponses(value = {
@ApiResponse(responseCode = "201", description = "created hello", @ApiResponse(responseCode = "201", description = "created hello",
content = {@Content(mediaType = "application/json", content = {@Content(mediaType = "application/json",
schema = @Schema(implementation = HelloGetDto.class))}), schema = @Schema(implementation = HelloGetDto.class))}),
@ApiResponse(responseCode = "400", description = "invalid JSON posted", @ApiResponse(responseCode = "400", description = "invalid JSON posted",
content = @Content), content = @Content),
@ApiResponse(responseCode = "401", description = "not authorized", @ApiResponse(responseCode = "401", description = "not authorized",
content = @Content)}) content = @Content)})
@PostMapping @PostMapping
public HelloGetDto create(@RequestBody @Valid HelloCreateDto helloCreateDto) { public HelloGetDto create(@RequestBody @Valid HelloCreateDto helloCreateDto) {
HelloEntity helloEntity = this.helloMapper.mapCreateDtoToEntity(helloCreateDto); HelloEntity helloEntity = this.helloMapper.mapCreateDtoToEntity(helloCreateDto);
helloEntity = this.service.create(helloEntity); helloEntity = this.service.create(helloEntity);
return this.helloMapper.mapToGetDto(helloEntity); return this.helloMapper.mapToGetDto(helloEntity);
} }
@Operation(summary = "deletes a Hello by id") @Operation(summary = "deletes a Hello by id")
@ApiResponses(value = { @ApiResponses(value = {
@ApiResponse(responseCode = "204", description = "delete successful"), @ApiResponse(responseCode = "204", description = "delete successful"),
@ApiResponse(responseCode = "401", description = "not authorized", @ApiResponse(responseCode = "401", description = "not authorized",
content = @Content), content = @Content),
@ApiResponse(responseCode = "404", description = "resource not found", @ApiResponse(responseCode = "404", description = "resource not found",
content = @Content)}) content = @Content)})
@DeleteMapping("/{id}") @DeleteMapping("/{id}")
@ResponseStatus(code = HttpStatus.NO_CONTENT) @ResponseStatus(code = HttpStatus.NO_CONTENT)
public void deleteHelloById(@PathVariable long id) { public void deleteHelloById(@PathVariable long id) {
var entity = this.service.readById(id); var entity = this.service.readById(id);
if (entity == null) { if (entity == null) {
throw new ResourceNotFoundException("HelloEntity not found on id = " + id); throw new ResourceNotFoundException("HelloEntity not found on id = " + id);
} else { } else {
this.service.delete(entity); this.service.delete(entity);
} }
} }
} }

54
src/main/java/de/szut/lf8_starter/hello/HelloEntity.java
View File

@ -1,27 +1,27 @@
package de.szut.lf8_starter.hello; package de.szut.lf8_starter.hello;
import jakarta.persistence.*; import jakarta.persistence.*;
import lombok.AllArgsConstructor; import lombok.AllArgsConstructor;
import lombok.Getter; import lombok.Getter;
import lombok.NoArgsConstructor; import lombok.NoArgsConstructor;
import lombok.Setter; import lombok.Setter;
@NoArgsConstructor @NoArgsConstructor
@AllArgsConstructor @AllArgsConstructor
@Getter @Getter
@Setter @Setter
@Entity @Entity
@Table(name = "hello") @Table(name = "hello")
public class HelloEntity { public class HelloEntity {
@Id @Id
@GeneratedValue(strategy = GenerationType.IDENTITY) @GeneratedValue(strategy = GenerationType.IDENTITY)
private long id; private long id;
private String message; private String message;
public HelloEntity(String message) { public HelloEntity(String message) {
this.message = message; this.message = message;
} }
} }

40
src/main/java/de/szut/lf8_starter/hello/HelloMapper.java
View File

@ -1,20 +1,20 @@
package de.szut.lf8_starter.hello; package de.szut.lf8_starter.hello;
import de.szut.lf8_starter.hello.dto.HelloCreateDto; import de.szut.lf8_starter.hello.dto.HelloCreateDto;
import de.szut.lf8_starter.hello.dto.HelloGetDto; import de.szut.lf8_starter.hello.dto.HelloGetDto;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@Service @Service
public class HelloMapper { public class HelloMapper {
public HelloGetDto mapToGetDto(HelloEntity entity) { public HelloGetDto mapToGetDto(HelloEntity entity) {
return new HelloGetDto(entity.getId(), entity.getMessage()); return new HelloGetDto(entity.getId(), entity.getMessage());
} }
public HelloEntity mapCreateDtoToEntity(HelloCreateDto dto) { public HelloEntity mapCreateDtoToEntity(HelloCreateDto dto) {
var entity = new HelloEntity(); var entity = new HelloEntity();
entity.setMessage(dto.getMessage()); entity.setMessage(dto.getMessage());
return entity; return entity;
} }
} }

24
src/main/java/de/szut/lf8_starter/hello/HelloRepository.java
View File

@ -1,12 +1,12 @@
package de.szut.lf8_starter.hello; package de.szut.lf8_starter.hello;
import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List; import java.util.List;
public interface HelloRepository extends JpaRepository<HelloEntity, Long> { public interface HelloRepository extends JpaRepository<HelloEntity, Long> {
List<HelloEntity> findByMessage(String message); List<HelloEntity> findByMessage(String message);
} }

80
src/main/java/de/szut/lf8_starter/hello/HelloService.java
View File

@ -1,40 +1,40 @@
package de.szut.lf8_starter.hello; package de.szut.lf8_starter.hello;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;
@Service @Service
public class HelloService { public class HelloService {
private final HelloRepository repository; private final HelloRepository repository;
public HelloService(HelloRepository repository) { public HelloService(HelloRepository repository) {
this.repository = repository; this.repository = repository;
} }
public HelloEntity create(HelloEntity entity) { public HelloEntity create(HelloEntity entity) {
return this.repository.save(entity); return this.repository.save(entity);
} }
public List<HelloEntity> readAll() { public List<HelloEntity> readAll() {
return this.repository.findAll(); return this.repository.findAll();
} }
public HelloEntity readById(long id) { public HelloEntity readById(long id) {
Optional<HelloEntity> optionalQualification = this.repository.findById(id); Optional<HelloEntity> optionalQualification = this.repository.findById(id);
if (optionalQualification.isEmpty()) { if (optionalQualification.isEmpty()) {
return null; return null;
} }
return optionalQualification.get(); return optionalQualification.get();
} }
public void delete(HelloEntity entity) { public void delete(HelloEntity entity) {
this.repository.delete(entity); this.repository.delete(entity);
} }
public List<HelloEntity> findByMessage(String message) { public List<HelloEntity> findByMessage(String message) {
return this.repository.findByMessage(message); return this.repository.findByMessage(message);
} }
} }

40
src/main/java/de/szut/lf8_starter/hello/dto/HelloCreateDto.java
View File

@ -1,20 +1,20 @@
package de.szut.lf8_starter.hello.dto; package de.szut.lf8_starter.hello.dto;
import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonCreator;
import jakarta.validation.constraints.Size; import jakarta.validation.constraints.Size;
import lombok.Getter; import lombok.Getter;
import lombok.Setter; import lombok.Setter;
@Getter @Getter
@Setter @Setter
public class HelloCreateDto { public class HelloCreateDto {
@Size(min = 3, message = "at least length of 3") @Size(min = 3, message = "at least length of 3")
private String message; private String message;
@JsonCreator @JsonCreator
public HelloCreateDto(String message) { public HelloCreateDto(String message) {
this.message = message; this.message = message;
} }
} }

34
src/main/java/de/szut/lf8_starter/hello/dto/HelloGetDto.java
View File

@ -1,17 +1,17 @@
package de.szut.lf8_starter.hello.dto; package de.szut.lf8_starter.hello.dto;
import lombok.AllArgsConstructor; import lombok.AllArgsConstructor;
import lombok.Getter; import lombok.Getter;
import lombok.Setter; import lombok.Setter;
@AllArgsConstructor @AllArgsConstructor
@Getter @Getter
@Setter @Setter
public class HelloGetDto { public class HelloGetDto {
private long id; private long id;
private String message; private String message;
} }

102
src/main/java/de/szut/lf8_starter/project/ProjectMapper.java
View File

@ -1,41 +1,61 @@
package de.szut.lf8_starter.project; package de.szut.lf8_starter.project;
import de.szut.lf8_starter.project.dto.CreateProjectDto; import de.szut.lf8_starter.project.dto.CreateProjectDto;
import de.szut.lf8_starter.project.dto.GetProjectDto; import de.szut.lf8_starter.project.dto.GetProjectDto;
import org.springframework.stereotype.Service; import de.szut.lf8_starter.project.dto.UpdateProjectDto;
import org.springframework.stereotype.Service;
@Service
public class ProjectMapper { @Service
public ProjectEntity mapCreateDtoToEntity(CreateProjectDto createProjectDto) { public class ProjectMapper {
ProjectEntity projectEntity = new ProjectEntity(); public ProjectEntity mapCreateDtoToEntity(CreateProjectDto createProjectDto) {
ProjectEntity projectEntity = new ProjectEntity();
projectEntity.setName(createProjectDto.getName());
projectEntity.setComment(createProjectDto.getComment()); projectEntity.setName(createProjectDto.getName());
projectEntity.setLeadingEmployee(createProjectDto.getLeadingEmployee()); projectEntity.setComment(createProjectDto.getComment());
projectEntity.setEmployees(createProjectDto.getEmployees()); projectEntity.setLeadingEmployee(createProjectDto.getLeadingEmployee());
projectEntity.setContractor(createProjectDto.getContractor()); projectEntity.setEmployees(createProjectDto.getEmployees());
projectEntity.setContractorName(createProjectDto.getContractorName()); projectEntity.setContractor(createProjectDto.getContractor());
projectEntity.setStartDate(createProjectDto.getStartDate()); projectEntity.setContractorName(createProjectDto.getContractorName());
projectEntity.setPlannedEndDate(createProjectDto.getPlannedEndDate()); projectEntity.setStartDate(createProjectDto.getStartDate());
projectEntity.setEndDate(createProjectDto.getEndDate()); projectEntity.setPlannedEndDate(createProjectDto.getPlannedEndDate());
projectEntity.setEndDate(createProjectDto.getEndDate());
return projectEntity;
} return projectEntity;
}
public GetProjectDto mapToGetDto(ProjectEntity projectEntity) {
GetProjectDto getProjectDto = new GetProjectDto(); public GetProjectDto mapToGetDto(ProjectEntity projectEntity) {
GetProjectDto getProjectDto = new GetProjectDto();
getProjectDto.setId(projectEntity.getId());
getProjectDto.setName(projectEntity.getName()); getProjectDto.setId(projectEntity.getId());
getProjectDto.setComment(projectEntity.getComment()); getProjectDto.setName(projectEntity.getName());
getProjectDto.setLeadingEmployee(projectEntity.getLeadingEmployee()); getProjectDto.setComment(projectEntity.getComment());
getProjectDto.setEmployees(projectEntity.getEmployees()); getProjectDto.setLeadingEmployee(projectEntity.getLeadingEmployee());
getProjectDto.setContractor(projectEntity.getContractor()); getProjectDto.setEmployees(projectEntity.getEmployees());
getProjectDto.setContractorName(projectEntity.getContractorName()); getProjectDto.setContractor(projectEntity.getContractor());
getProjectDto.setStartDate(projectEntity.getStartDate()); getProjectDto.setContractorName(projectEntity.getContractorName());
getProjectDto.setPlannedEndDate(projectEntity.getPlannedEndDate()); getProjectDto.setStartDate(projectEntity.getStartDate());
getProjectDto.setEndDate(projectEntity.getEndDate()); getProjectDto.setPlannedEndDate(projectEntity.getPlannedEndDate());
getProjectDto.setEndDate(projectEntity.getEndDate());
return getProjectDto;
} return getProjectDto;
} }
public ProjectEntity mapUpdateDtoToEntity(UpdateProjectDto updateProjectDto, ProjectEntity projectEntity) {
projectEntity.setName(updateProjectDto.getName() != null ? updateProjectDto.getName() : projectEntity.getName());
projectEntity.setLeadingEmployee(updateProjectDto.getLeadingEmployee() != null ? updateProjectDto.getLeadingEmployee() : projectEntity.getLeadingEmployee());
projectEntity.setContractor(updateProjectDto.getContractor() != null ? updateProjectDto.getContractor() : projectEntity.getContractor());
projectEntity.setContractorName(updateProjectDto.getContractorName() != null ? updateProjectDto.getContractorName() : projectEntity.getContractorName());
projectEntity.setComment(updateProjectDto.getComment() != null ? updateProjectDto.getComment() : projectEntity.getComment());
projectEntity.setStartDate(updateProjectDto.getStartDate() != null ? updateProjectDto.getStartDate() : projectEntity.getStartDate());
projectEntity.setPlannedEndDate(updateProjectDto.getPlannedEndDate() != null ? updateProjectDto.getPlannedEndDate() : projectEntity.getPlannedEndDate());
projectEntity.setEndDate(updateProjectDto.getEndDate() != null ? updateProjectDto.getEndDate() : projectEntity.getEndDate());
if (updateProjectDto.getEmployees() != null) {
projectEntity.getEmployees().clear();
projectEntity.setEmployees(updateProjectDto.getEmployees());
}
return projectEntity;
}
}

67
src/main/java/de/szut/lf8_starter/project/ProjectService.java
View File

@ -1,34 +1,33 @@
package de.szut.lf8_starter.project; package de.szut.lf8_starter.project;
import de.szut.lf8_starter.exceptionHandling.ResourceNotFoundException; import org.springframework.stereotype.Service;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.List; import java.util.Optional;
import java.util.Optional;
@Service
@Service public class ProjectService {
public class ProjectService { private final ProjectRepository projectRepository;
private final ProjectRepository projectRepository;
public ProjectService(ProjectRepository projectRepository) {
public ProjectService(ProjectRepository projectRepository) { this.projectRepository = projectRepository;
this.projectRepository = projectRepository; }
}
public ProjectEntity create(ProjectEntity projectEntity) {
public ProjectEntity create(ProjectEntity projectEntity) { return this.projectRepository.save(projectEntity);
return this.projectRepository.save(projectEntity); }
}
public List<ProjectEntity> readAll() {
public List<ProjectEntity> readAll() { return this.projectRepository.findAll();
return this.projectRepository.findAll(); }
}
public Optional<ProjectEntity> findById(Long id) {
public ProjectEntity findById(Long id) { return projectRepository.findById(id);
Optional<ProjectEntity> articleEntity = projectRepository.findById(id); }
if (articleEntity.isEmpty()) { public ProjectEntity update(ProjectEntity project) {
throw new ResourceNotFoundException("Project with id " + id + " not found"); this.projectRepository.save(project);
}
return project;
return articleEntity.get(); }
} }
}

86
src/main/java/de/szut/lf8_starter/project/action/GetProjectAction.java
View File

@ -1,40 +1,46 @@
package de.szut.lf8_starter.project.action; package de.szut.lf8_starter.project.action;
import de.szut.lf8_starter.project.ProjectEntity; import de.szut.lf8_starter.project.ProjectEntity;
import de.szut.lf8_starter.project.ProjectMapper; import de.szut.lf8_starter.project.ProjectMapper;
import de.szut.lf8_starter.project.ProjectService; import de.szut.lf8_starter.project.ProjectService;
import de.szut.lf8_starter.project.dto.GetProjectDto; import de.szut.lf8_starter.project.dto.GetProjectDto;
import io.swagger.v3.oas.annotations.Operation; import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content; import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse; import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses; import io.swagger.v3.oas.annotations.responses.ApiResponses;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
@RestController import java.util.Optional;
@RequestMapping(value = "projects")
public class GetProjectAction { @RestController
private final ProjectService projectService; @RequestMapping(value = "projects")
private final ProjectMapper projectMapper; public class GetProjectAction {
private final ProjectService projectService;
public GetProjectAction(ProjectService projectService, ProjectMapper projectMapper) { private final ProjectMapper projectMapper;
this.projectService = projectService;
this.projectMapper = projectMapper; public GetProjectAction(ProjectService projectService, ProjectMapper projectMapper) {
} this.projectService = projectService;
this.projectMapper = projectMapper;
@Operation(summary = "Find project by ID") }
@ApiResponses(value = {
@ApiResponse(responseCode = "200", description = "Project found", content = { @Operation(summary = "Find project by ID")
@Content(mediaType = "application/json", schema = @Schema(implementation = GetProjectDto.class)) @ApiResponses(value = {
}), @ApiResponse(responseCode = "200", description = "Project found", content = {
@ApiResponse(responseCode = "404", description = "Project not found", content = @Content) @Content(mediaType = "application/json", schema = @Schema(implementation = GetProjectDto.class))
}) }),
@GetMapping("/{id}") @ApiResponse(responseCode = "404", description = "Project not found", content = @Content)
public ResponseEntity<GetProjectDto> findArticleById(@PathVariable Long id) { })
ProjectEntity project = this.projectService.findById(id); @GetMapping("/{id}")
public ResponseEntity<GetProjectDto> findArticleById(@PathVariable Long id) {
return new ResponseEntity<>(this.projectMapper.mapToGetDto(project), HttpStatus.OK); Optional<ProjectEntity> project = this.projectService.findById(id);
}
} if (project.isEmpty()) {
return new ResponseEntity<>(HttpStatus.NOT_FOUND);
}
return new ResponseEntity<>(this.projectMapper.mapToGetDto(project.get()), HttpStatus.OK);
}
}

50
src/main/java/de/szut/lf8_starter/project/action/UpdateProjectAction.java Normal file
View File

@ -0,0 +1,50 @@
package de.szut.lf8_starter.project.action;
import de.szut.lf8_starter.project.ProjectEntity;
import de.szut.lf8_starter.project.ProjectMapper;
import de.szut.lf8_starter.project.ProjectService;
import de.szut.lf8_starter.project.dto.GetProjectDto;
import de.szut.lf8_starter.project.dto.UpdateProjectDto;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.Optional;
@RestController
@RequestMapping(value = "/projects")
public class UpdateProjectAction {
private final ProjectService projectService;
private final ProjectMapper projectMapper;
public UpdateProjectAction(ProjectService projectService, ProjectMapper mappingService) {
this.projectService = projectService;
this.projectMapper = mappingService;
}
@Operation(summary = "Update a project by ID")
@ApiResponses(value = {
@ApiResponse(responseCode = "200", description = "Project updated successfully",
content = @Content(mediaType = "application/json", schema = @Schema(implementation = GetProjectDto.class))),
@ApiResponse(responseCode = "404", description = "Project not found", content = @Content)
})
@PutMapping("/{id}")
public ResponseEntity<GetProjectDto> updateSupplier(@PathVariable Long id, @Valid @RequestBody UpdateProjectDto updateProjectDto) {
Optional<ProjectEntity> project = this.projectService.findById(id);
if (project.isEmpty()) {
return new ResponseEntity<>(HttpStatus.NOT_FOUND);
}
ProjectEntity updatedProject = this.projectMapper.mapUpdateDtoToEntity(updateProjectDto, project.get());
this.projectService.update(updatedProject);
return new ResponseEntity<>(this.projectMapper.mapToGetDto(updatedProject), HttpStatus.OK);
}
}

36
src/main/java/de/szut/lf8_starter/project/dto/UpdateProjectDto.java Normal file
View File

@ -0,0 +1,36 @@
package de.szut.lf8_starter.project.dto;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.PropertyNamingStrategies;
import com.fasterxml.jackson.databind.annotation.JsonNaming;
import lombok.Getter;
import lombok.Setter;
import java.time.LocalDate;
import java.util.List;
@Getter
@Setter
@JsonNaming(PropertyNamingStrategies.SnakeCaseStrategy.class)
public class UpdateProjectDto {
private String name;
private Long leadingEmployee;
private List<Long> employees;
private Long contractor;
private String contractorName;
private String comment;
@JsonFormat(pattern = "dd.MM.yyyy")
private LocalDate startDate;
@JsonFormat(pattern = "dd.MM.yyyy")
private LocalDate plannedEndDate;
@JsonFormat(pattern = "dd.MM.yyyy")
private LocalDate endDate;
}

98
src/main/java/de/szut/lf8_starter/security/KeycloakLogoutHandler.java
View File

@ -1,49 +1,49 @@
package de.szut.lf8_starter.security; package de.szut.lf8_starter.security;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication; import org.springframework.security.core.Authentication;
import org.springframework.security.oauth2.core.oidc.user.OidcUser; import org.springframework.security.oauth2.core.oidc.user.OidcUser;
import org.springframework.security.web.authentication.logout.LogoutHandler; import org.springframework.security.web.authentication.logout.LogoutHandler;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate; import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder; import org.springframework.web.util.UriComponentsBuilder;
import jakarta.servlet.http.HttpServletRequest; import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse; import jakarta.servlet.http.HttpServletResponse;
@Slf4j @Slf4j
@Component @Component
public class KeycloakLogoutHandler implements LogoutHandler { public class KeycloakLogoutHandler implements LogoutHandler {
private final RestTemplate restTemplate; private final RestTemplate restTemplate;
public KeycloakLogoutHandler(RestTemplate restTemplate) { public KeycloakLogoutHandler(RestTemplate restTemplate) {
this.restTemplate = restTemplate; this.restTemplate = restTemplate;
} }
@Override @Override
public void logout(HttpServletRequest request, HttpServletResponse response, Authentication auth) { public void logout(HttpServletRequest request, HttpServletResponse response, Authentication auth) {
logout(auth); logout(auth);
} }
public void logout(Authentication auth) { public void logout(Authentication auth) {
logoutFromKeycloak((OidcUser) auth.getPrincipal()); logoutFromKeycloak((OidcUser) auth.getPrincipal());
} }
private void logoutFromKeycloak(OidcUser user) { private void logoutFromKeycloak(OidcUser user) {
String endSessionEndpoint = user.getIssuer() + "/protocol/openid-connect/logout"; String endSessionEndpoint = user.getIssuer() + "/protocol/openid-connect/logout";
UriComponentsBuilder builder = UriComponentsBuilder UriComponentsBuilder builder = UriComponentsBuilder
.fromUriString(endSessionEndpoint) .fromUriString(endSessionEndpoint)
.queryParam("id_token_hint", user.getIdToken().getTokenValue()); .queryParam("id_token_hint", user.getIdToken().getTokenValue());
ResponseEntity<String> logoutResponse = restTemplate.getForEntity(builder.toUriString(), String.class); ResponseEntity<String> logoutResponse = restTemplate.getForEntity(builder.toUriString(), String.class);
if (logoutResponse.getStatusCode().is2xxSuccessful()) { if (logoutResponse.getStatusCode().is2xxSuccessful()) {
log.info("Successfulley logged out from Keycloak"); log.info("Successfulley logged out from Keycloak");
} else { } else {
log.error("Could not propagate logout to Keycloak"); log.error("Could not propagate logout to Keycloak");
} }
} }
} }

188
src/main/java/de/szut/lf8_starter/security/KeycloakSecurityConfig.java
View File

@ -1,94 +1,94 @@
package de.szut.lf8_starter.security; package de.szut.lf8_starter.security;
import java.util.*; import java.util.*;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile; import org.springframework.context.annotation.Profile;
import org.springframework.http.HttpMethod; import org.springframework.http.HttpMethod;
import org.springframework.security.config.Customizer; import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority; import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.authority.mapping.GrantedAuthoritiesMapper; import org.springframework.security.core.authority.mapping.GrantedAuthoritiesMapper;
import org.springframework.security.core.session.SessionRegistry; import org.springframework.security.core.session.SessionRegistry;
import org.springframework.security.core.session.SessionRegistryImpl; import org.springframework.security.core.session.SessionRegistryImpl;
import org.springframework.security.oauth2.core.oidc.user.OidcUserAuthority; import org.springframework.security.oauth2.core.oidc.user.OidcUserAuthority;
import org.springframework.security.oauth2.core.user.OAuth2UserAuthority; import org.springframework.security.oauth2.core.user.OAuth2UserAuthority;
import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter; import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter;
import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter; import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter;
import org.springframework.security.web.SecurityFilterChain; import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.session.RegisterSessionAuthenticationStrategy; import org.springframework.security.web.authentication.session.RegisterSessionAuthenticationStrategy;
import org.springframework.security.web.authentication.session.SessionAuthenticationStrategy; import org.springframework.security.web.authentication.session.SessionAuthenticationStrategy;
import org.springframework.security.web.session.HttpSessionEventPublisher; import org.springframework.security.web.session.HttpSessionEventPublisher;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher; import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
@Configuration @Configuration
@EnableWebSecurity @EnableWebSecurity
class KeycloakSecurityConfig { class KeycloakSecurityConfig {
private static final String REALM_ACCESS_CLAIM = "realm_access"; private static final String REALM_ACCESS_CLAIM = "realm_access";
private static final String ROLES_CLAIM = "roles"; private static final String ROLES_CLAIM = "roles";
KeycloakSecurityConfig() { KeycloakSecurityConfig() {
} }
@Bean @Bean
public SessionRegistry sessionRegistry() { public SessionRegistry sessionRegistry() {
return new SessionRegistryImpl(); return new SessionRegistryImpl();
} }
@Bean @Bean
protected SessionAuthenticationStrategy sessionAuthenticationStrategy() { protected SessionAuthenticationStrategy sessionAuthenticationStrategy() {
return new RegisterSessionAuthenticationStrategy(sessionRegistry()); return new RegisterSessionAuthenticationStrategy(sessionRegistry());
} }
@Bean @Bean
public HttpSessionEventPublisher httpSessionEventPublisher() { public HttpSessionEventPublisher httpSessionEventPublisher() {
return new HttpSessionEventPublisher(); return new HttpSessionEventPublisher();
} }
@Bean @Bean
public SecurityFilterChain resourceServerFilterChain(HttpSecurity http) throws Exception { public SecurityFilterChain resourceServerFilterChain(HttpSecurity http) throws Exception {
http.authorizeHttpRequests(auth -> auth http.authorizeHttpRequests(auth -> auth
.requestMatchers(new AntPathRequestMatcher("/welcome")) .requestMatchers(new AntPathRequestMatcher("/welcome"))
.permitAll() .permitAll()
.requestMatchers( .requestMatchers(
new AntPathRequestMatcher("/swagger"), new AntPathRequestMatcher("/swagger"),
new AntPathRequestMatcher("/swagger-ui/**"), new AntPathRequestMatcher("/swagger-ui/**"),
new AntPathRequestMatcher("/v3/api-docs/**")) new AntPathRequestMatcher("/v3/api-docs/**"))
.permitAll() .permitAll()
.requestMatchers(new AntPathRequestMatcher("/hello/**")) .requestMatchers(new AntPathRequestMatcher("/hello/**"))
.hasRole("user") .hasRole("user")
.requestMatchers(new AntPathRequestMatcher("/roles")) .requestMatchers(new AntPathRequestMatcher("/roles"))
.authenticated() .authenticated()
.requestMatchers(new AntPathRequestMatcher("/")) .requestMatchers(new AntPathRequestMatcher("/"))
.permitAll() .permitAll()
.anyRequest() .anyRequest()
.authenticated()).oauth2ResourceServer(spec -> spec.jwt(Customizer.withDefaults())); .authenticated()).oauth2ResourceServer(spec -> spec.jwt(Customizer.withDefaults()));
return http.build(); return http.build();
} }
@Bean @Bean
public JwtAuthenticationConverter jwtAuthenticationConverter() { public JwtAuthenticationConverter jwtAuthenticationConverter() {
JwtAuthenticationConverter jwtAuthenticationConverter = new JwtAuthenticationConverter(); JwtAuthenticationConverter jwtAuthenticationConverter = new JwtAuthenticationConverter();
jwtAuthenticationConverter.setJwtGrantedAuthoritiesConverter(jwt -> { jwtAuthenticationConverter.setJwtGrantedAuthoritiesConverter(jwt -> {
List<GrantedAuthority> grantedAuthorities = new ArrayList<>(); List<GrantedAuthority> grantedAuthorities = new ArrayList<>();
Map<String, Object> realmAccess = jwt.getClaim(REALM_ACCESS_CLAIM); Map<String, Object> realmAccess = jwt.getClaim(REALM_ACCESS_CLAIM);
if (realmAccess != null && realmAccess.containsKey(ROLES_CLAIM)) { if (realmAccess != null && realmAccess.containsKey(ROLES_CLAIM)) {
List<String> roles = (List<String>) realmAccess.get(ROLES_CLAIM); List<String> roles = (List<String>) realmAccess.get(ROLES_CLAIM);
for (String role : roles) { for (String role : roles) {
grantedAuthorities.add(new SimpleGrantedAuthority("ROLE_" + role)); grantedAuthorities.add(new SimpleGrantedAuthority("ROLE_" + role));
} }
} }
return grantedAuthorities; return grantedAuthorities;
}); });
return jwtAuthenticationConverter; return jwtAuthenticationConverter;
} }
} }

50
src/main/java/de/szut/lf8_starter/welcome/WelcomeController.java
View File

@ -1,25 +1,25 @@
package de.szut.lf8_starter.welcome; package de.szut.lf8_starter.welcome;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication; import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.GrantedAuthority;
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
import java.util.Collection; import java.util.Collection;
@RestController @RestController
public class WelcomeController { public class WelcomeController {
@GetMapping("/welcome") @GetMapping("/welcome")
public String welcome() { public String welcome() {
return "welcome to lf8_starter"; return "welcome to lf8_starter";
} }
@GetMapping("/roles") @GetMapping("/roles")
public ResponseEntity<Collection<GrantedAuthority>> getRoles(Authentication authentication) { public ResponseEntity<Collection<GrantedAuthority>> getRoles(Authentication authentication) {
return ResponseEntity.ok((Collection<GrantedAuthority>) authentication.getAuthorities()); return ResponseEntity.ok((Collection<GrantedAuthority>) authentication.getAuthorities());
} }
} }

113
src/test/java/de/szut/lf8_starter/integration/project/FindProjectActionTest.java → src/test/java/de/szut/lf8_starter/integration/project/GetProjectActionTest.java
View File

@ -1,54 +1,59 @@
package de.szut.lf8_starter.integration.project; package de.szut.lf8_starter.integration.project;
import de.szut.lf8_starter.project.ProjectEntity; import de.szut.lf8_starter.project.ProjectEntity;
import de.szut.lf8_starter.project.ProjectRepository; import de.szut.lf8_starter.project.ProjectRepository;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MockMvc;
import java.time.LocalDate; import java.time.LocalDate;
import java.util.List; import java.util.List;
import static org.hamcrest.collection.IsCollectionWithSize.hasSize; import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@SpringBootTest @SpringBootTest
@AutoConfigureMockMvc(addFilters = false) @AutoConfigureMockMvc(addFilters = false)
class FindProjectActionTest { class GetProjectActionTest {
@Autowired @Autowired
private MockMvc mockMvc; private MockMvc mockMvc;
@Autowired @Autowired
private ProjectRepository projectRepository; private ProjectRepository projectRepository;
@Test @Test
void createProjectTest() throws Exception { void getProjectTest() throws Exception {
var project = new ProjectEntity(); var project = new ProjectEntity();
project.setId(1); project.setId(1);
project.setComment("comment"); project.setComment("comment");
project.setContractor(1); project.setContractor(1);
project.setContractorName("contractorName"); project.setContractorName("contractorName");
project.setEndDate(LocalDate.of(2024, 1, 1)); project.setEndDate(LocalDate.of(2024, 1, 1));
project.setLeadingEmployee(1); project.setLeadingEmployee(1);
project.setName("name"); project.setName("name");
project.setStartDate(LocalDate.of(2021, 1, 1)); project.setStartDate(LocalDate.of(2021, 1, 1));
project.setEmployees(List.of(1L, 2L, 3L)); project.setEmployees(List.of(1L, 2L, 3L));
this.projectRepository.save(project); this.projectRepository.save(project);
this.mockMvc.perform(get("/projects/1")) this.mockMvc.perform(get("/projects/1"))
.andExpect(status().isOk()) .andExpect(status().isOk())
.andExpect(jsonPath("id").value(1)) .andExpect(jsonPath("id").value(1))
.andExpect(jsonPath("comment").value("comment")) .andExpect(jsonPath("comment").value("comment"))
.andExpect(jsonPath("contractor").value(1)) .andExpect(jsonPath("contractor").value(1))
.andExpect(jsonPath("contractor_name").value("contractorName")) .andExpect(jsonPath("contractor_name").value("contractorName"))
.andExpect(jsonPath("end_date").value("01.01.2024")) .andExpect(jsonPath("end_date").value("01.01.2024"))
.andExpect(jsonPath("leading_employee").value(1)) .andExpect(jsonPath("leading_employee").value(1))
.andExpect(jsonPath("name").value("name")) .andExpect(jsonPath("name").value("name"))
.andExpect(jsonPath("start_date").value("01.01.2021")) .andExpect(jsonPath("start_date").value("01.01.2021"))
.andExpect(jsonPath("employees").isArray()) .andExpect(jsonPath("employees").isArray())
.andExpect(jsonPath("employees", hasSize(3))); .andExpect(jsonPath("employees", hasSize(3)));
} }
}
@Test
void getProjectShouldReturnNotFoundResponseWhenProjectIsNotFound() throws Exception {
this.mockMvc.perform(get("/projects/2")).andExpect(status().isNotFound());
}
}

140
src/test/java/de/szut/lf8_starter/integration/project/UpdateProjectActionTest.java Normal file
View File

@ -0,0 +1,140 @@
package de.szut.lf8_starter.integration.project;
import de.szut.lf8_starter.project.ProjectEntity;
import de.szut.lf8_starter.project.ProjectRepository;
import org.json.JSONObject;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import java.time.LocalDate;
import java.util.Arrays;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.is;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@SpringBootTest
@AutoConfigureMockMvc(addFilters = false)
class UpdateProjectActionTest {
@Autowired
private MockMvc mockMvc;
@Autowired
private ProjectRepository projectRepository;
@Test
void updateProjectShouldUpdateProject() throws Exception {
ProjectEntity project = new ProjectEntity();
project.setId(1);
project.setComment("comment");
project.setContractor(1);
project.setContractorName("contractorName");
project.setEndDate(LocalDate.of(2024, 1, 1));
project.setLeadingEmployee(1);
project.setName("name");
project.setStartDate(LocalDate.of(2021, 1, 1));
project.setEmployees(List.of(1L, 2L, 3L));
this.projectRepository.save(project);
String content = """
{
"name": "updatedName",
"leading_employee": 2,
"employees": [3, 4, 5],
"contractor": 6,
"contractor_name": "Updated Contractor name",
"comment": "new goal of project",
"start_date": "01.01.2021",
"planned_end_date": "01.01.2022"
}
""";
final var contentAsString = this.mockMvc.perform(
put("/projects/1").content(content).contentType(MediaType.APPLICATION_JSON)
)
.andExpect(status().isOk())
.andExpect(jsonPath("name", is("updatedName")))
.andExpect(jsonPath("leading_employee", is(2)))
.andExpect(jsonPath("employees", is(Arrays.asList(3, 4, 5))))
.andExpect(jsonPath("contractor", is(6)))
.andExpect(jsonPath("contractor_name", is("Updated Contractor name")))
.andExpect(jsonPath("comment", is("new goal of project")))
.andExpect(jsonPath("start_date", is("01.01.2021")))
.andExpect(jsonPath("planned_end_date", is("01.01.2022")))
.andReturn()
.getResponse()
.getContentAsString();
final var id = Long.parseLong(new JSONObject(contentAsString).get("id").toString());
final var existingProject = this.projectRepository.findById(id);
assertThat(existingProject.get().getName()).isEqualTo("updatedName");
assertThat(existingProject.get().getLeadingEmployee()).isEqualTo(2);
assertThat(existingProject.get().getContractor()).isEqualTo(6);
assertThat(existingProject.get().getContractorName()).isEqualTo("Updated Contractor name");
assertThat(existingProject.get().getComment()).isEqualTo("new goal of project");
assertThat(existingProject.get().getStartDate()).isEqualTo(LocalDate.of(2021, 1, 1));
assertThat(existingProject.get().getPlannedEndDate()).isEqualTo(LocalDate.of(2022, 1, 1));
}
@Test
void updateProjectShouldUpdateProjectPartially() throws Exception {
ProjectEntity project = new ProjectEntity();
project.setId(1);
project.setName("name");
project.setLeadingEmployee(1);
project.setContractor(1);
project.setComment("comment");
project.setEmployees(List.of(1L, 2L, 3L));
project.setContractorName("contractorName");
project.setStartDate(LocalDate.of(2021, 1, 1));
project.setPlannedEndDate(LocalDate.of(2023, 1, 1));
project.setEndDate(LocalDate.of(2024, 1, 1));
this.projectRepository.save(project);
String content = """
{}
""";
final var contentAsString = this.mockMvc.perform(
put("/projects/1").content(content).contentType(MediaType.APPLICATION_JSON)
)
.andExpect(status().isOk())
.andExpect(jsonPath("name", is("name")))
.andExpect(jsonPath("leading_employee", is(1)))
.andExpect(jsonPath("employees", is(List.of(1,2,3))))
.andExpect(jsonPath("contractor", is(1)))
.andExpect(jsonPath("contractor_name", is("contractorName")))
.andExpect(jsonPath("comment", is("comment")))
.andExpect(jsonPath("start_date", is("01.01.2021")))
.andExpect(jsonPath("planned_end_date", is("01.01.2023")))
.andExpect(jsonPath("end_date", is("01.01.2024")))
.andReturn()
.getResponse()
.getContentAsString();
final var id = Long.parseLong(new JSONObject(contentAsString).get("id").toString());
final var existingProject = this.projectRepository.findById(id);
assertThat(existingProject.get().getName()).isEqualTo("name");
assertThat(existingProject.get().getLeadingEmployee()).isEqualTo(1);
assertThat(existingProject.get().getContractor()).isEqualTo(1);
assertThat(existingProject.get().getContractorName()).isEqualTo("contractorName");
assertThat(existingProject.get().getComment()).isEqualTo("comment");
assertThat(existingProject.get().getStartDate()).isEqualTo(LocalDate.of(2021, 1, 1));
assertThat(existingProject.get().getPlannedEndDate()).isEqualTo(LocalDate.of(2023, 1, 1));
assertThat(existingProject.get().getEndDate()).isEqualTo(LocalDate.of(2024, 1, 1));
}
@Test
void updateProjectShouldReturnNotFoundResponseWhenProjectIsNotFound() throws Exception {
this.mockMvc.perform(put("/projects/2").content("{}").contentType(MediaType.APPLICATION_JSON)).andExpect(status().isNotFound());
}
}