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

Merged
jank merged 8 commits from feature/update-project into main 2024-10-02 08:52:19 +00:00
Conversation 7 Commits 8 Files Changed 23 +1065 -786
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());
}
}