Backend test

backend/src/main/java/com/claim/api/config/WebSecurityConfig.java

@@ -24,7 +24,6 @@ public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Excepti
                 .requestMatchers("/public/**", "/auth/**").permitAll()
                 .requestMatchers("/api/v1/admin", "/api/v1/admin/**").hasRole("SUPER_ADMIN")
                 .requestMatchers("/api/v1/department", "/api/v1/department/**").hasRole("SUPER_ADMIN")
-                .requestMatchers("/api/v1/user", "/api/v1/user/**").authenticated()
                 .requestMatchers("/", "/error", "/csrf", "/swagger-ui.html", "/swagger-ui/**", "/v3/api-docs", "/v3/api-docs/**").permitAll()
                 .anyRequest().authenticated()
                 .and()

backend/src/main/java/com/claim/api/controller/TaskController.java

@@ -0,0 +1,51 @@
+package com.claim.api.controller;
+
+
+import com.claim.api.entity.Task;
+import com.claim.api.service.TaskService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Set;
+
+@RestController
+@RequestMapping("/api/v1/task")
+public class TaskController {
+
+    private final TaskService taskService;
+
+    @Autowired
+    public TaskController(TaskService taskService) {
+        this.taskService = taskService;
+    }
+
+    @PreAuthorize("hasAuthority('ROLE_SUPER_ADMIN')")
+    @GetMapping
+    public ResponseEntity<Page<Task>> getTasks(@RequestParam(defaultValue = "0") int page,
+                                               @RequestParam(defaultValue = "10") int size,
+                                               @RequestParam(defaultValue = "ASC") String sortBy,
+                                               @RequestParam(defaultValue = "id") String[] sort) {
+        PageRequest pageRequest = PageRequest.of(page, size , Sort.by(Sort.Direction.fromString(sortBy), sort));
+        return ResponseEntity.ok(taskService.getTasks(pageRequest));
+    }
+
+    @GetMapping("{id}")
+    public ResponseEntity<Task> getTask(@PathVariable Long id) {
+        return ResponseEntity.ok(taskService.getTaskById(id));
+    }
+
+    @GetMapping("/user={id}")
+    public ResponseEntity<Set<Task>> getTasksByUserId(@PathVariable Long id) {
+        return ResponseEntity.ok(taskService.getTasksByUserId(id));
+    }
+
+    @PostMapping("/user={id}")
+    public ResponseEntity<Task> createTask(@PathVariable Long id, @RequestBody Task task) {
+        return ResponseEntity.ok(taskService.createTask(id, task));
+    }
+}

backend/src/main/java/com/claim/api/controller/UserController.java

@@ -8,6 +8,10 @@
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.security.SecurityRequirement;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.access.prepost.PreAuthorize;
@@ -34,11 +38,16 @@ public UserController(UserService userService, UserMapper userMapper) {
     }
 
     @Operation(security = {@SecurityRequirement(name = BASIC_AUTH_SECURITY_SCHEME)})
-    @GetMapping("/user")
-    public ResponseEntity<List<UserDto>> getUsers() {
-        return new ResponseEntity<>(userService.getUserList().stream()
+    @GetMapping
+    public ResponseEntity<Page<UserDto>> getUsers(@RequestParam(defaultValue = "0") int page,
+                                                  @RequestParam(defaultValue = "10") int size,
+                                                  @RequestParam(defaultValue = "ASC") String sortBy,
+                                                  @RequestParam(defaultValue = "id") String[] sort) {
+        PageRequest pageRequest = PageRequest.of(page, size , Sort.by(Sort.Direction.fromString(sortBy), sort));
+        List<UserDto> users = userService.getUserList(pageRequest).stream()
                 .map(userMapper::toUserDto)
-                .collect(Collectors.toList()), HttpStatus.OK);
+                .toList();
+        return ResponseEntity.ok(new PageImpl<>(users));
     }
 
     @Operation(security = {@SecurityRequirement(name = BASIC_AUTH_SECURITY_SCHEME)})

backend/src/main/java/com/claim/api/controller/dto/UserDto.java

@@ -3,5 +3,5 @@
 import com.claim.api.entity.Profile;
 import com.claim.api.entity.Role;
 
-public record UserDto(Long id, String username, Role role, Profile profile) {
+public record UserDto(Long id, String username, Role role) {
 }

backend/src/main/java/com/claim/api/entity/Department.java

@@ -2,12 +2,16 @@
 
 
 import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 import lombok.Setter;
 
 @Getter
 @Setter
 @Entity
+@AllArgsConstructor
+@NoArgsConstructor
 @Table(name = "department")
 public class Department {
 

backend/src/main/java/com/claim/api/entity/Profile.java

@@ -16,7 +16,6 @@ public class Profile {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
-
     @Column(name = "firstname")
     private String firstname;
     @Column(name = "lastname")

backend/src/main/java/com/claim/api/entity/User.java

@@ -2,6 +2,7 @@
 
 import jakarta.persistence.*;
 import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -28,6 +29,7 @@ public class User implements UserDetails {
     private Long id;
 
     @Column(name = "username")
+    @Size(min = 5, max = 25)
     private String username;
 
     @Column(name = "password")
@@ -43,7 +45,7 @@ public class User implements UserDetails {
 
     @OneToMany(cascade = CascadeType.ALL)
     @JoinColumn(name = "user_id")
-    private Set<Task> task = new HashSet<Task>();
+    private Set<Task> task = new HashSet<>();
 
     boolean isEnable;
 
@@ -76,4 +78,8 @@ public boolean isCredentialsNonExpired() {
     public boolean isEnabled() {
         return true;
     }
+
+    public void setTask(Task task) {
+        this.task.add(task);
+    }
 }

backend/src/main/java/com/claim/api/exception/ValidationExceptionHandler.java → backend/src/main/java/com/claim/api/exception/AdviceExceptionHandler.java

@@ -12,7 +12,7 @@
 import java.util.stream.Collectors;
 
 @RestControllerAdvice
-public class ValidationExceptionHandler {
+public class AdviceExceptionHandler {
 
     @ExceptionHandler(ConstraintViolationException.class)
     @ResponseStatus(HttpStatus.BAD_REQUEST)
@@ -44,4 +44,10 @@ public ResponseEntity<CustomResponseException> badRequestException(BadRequestExc
         CustomResponseException customResponseException = new CustomResponseException(ex.getMessage());
         return new ResponseEntity<>(customResponseException, HttpStatus.BAD_REQUEST);
     }
+
+    @ExceptionHandler(UserNotFoundException.class)
+    public ResponseEntity<CustomResponseException> userNotFoundException(UserNotFoundException ex) {
+        CustomResponseException customResponseException = new CustomResponseException(ex.getMessage());
+        return new ResponseEntity<>(customResponseException, HttpStatus.BAD_REQUEST);
+    }
 }

backend/src/main/java/com/claim/api/mapper/UserMapper.java

@@ -10,6 +10,6 @@ public class UserMapper {
     public UserDto toUserDto(User user) {
         if (user == null)
             return null;
-        return new UserDto(user.getId(), user.getUsername(), user.getRole(), user.getProfile());
+        return new UserDto(user.getId(), user.getUsername(), user.getRole());
     }
 }

backend/src/main/java/com/claim/api/repository/TaskRepository.java

@@ -0,0 +1,13 @@
+package com.claim.api.repository;
+
+import com.claim.api.entity.Task;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface TaskRepository extends JpaRepository<Task, Long> {
+
+}

backend/src/main/java/com/claim/api/service/TaskService.java

@@ -0,0 +1,62 @@
+package com.claim.api.service;
+
+import com.claim.api.entity.Task;
+import com.claim.api.entity.User;
+import com.claim.api.exception.BadRequestException;
+import com.claim.api.exception.UserNotFoundException;
+import com.claim.api.repository.TaskRepository;
+import com.claim.api.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.stereotype.Service;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+@Service
+public class TaskService {
+
+    private final TaskRepository taskRepository;
+    private final UserRepository userRepository;
+
+    @Autowired
+    public TaskService(TaskRepository taskRepository, UserRepository userRepository) {
+        this.taskRepository = taskRepository;
+        this.userRepository = userRepository;
+    }
+
+    public Page<Task> getTasks(PageRequest pageRequest) {
+        return taskRepository.findAll(pageRequest);
+    }
+
+    public Task getTaskById(Long id) {
+        Optional<Task> taskOptional = taskRepository.findById(id);
+        if (taskOptional.isPresent()) {
+            return taskOptional.get();
+        }
+        throw new BadRequestException("Task id=" + id + " not exist");
+    }
+
+    public Set<Task> getTasksByUserId(Long id) {
+        Optional<User> userOptional = userRepository.findById(id);
+        if (userOptional.isPresent()) {
+            return userOptional.get().getTask();
+        }
+        throw new UserNotFoundException("User id=" + id + " not exist");
+    }
+
+    public Task createTask(Long id, Task task) {
+        Optional<User> userOptional = userRepository.findById(id);
+        if (userOptional.isPresent()) {
+            User user = userOptional.get();
+            task.setDepartment(user.getProfile().getDepartment());
+            userOptional.get().setTask(task);
+            taskRepository.save(task);
+            return task;
+        }
+        throw new UserNotFoundException("User id=" + id + " not exist");
+    }
+}

backend/src/main/java/com/claim/api/service/UserService.java

@@ -5,13 +5,14 @@
 import com.claim.api.exception.UserNotFoundException;
 import com.claim.api.repository.UserRepository;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.security.core.userdetails.UserDetails;
 import org.springframework.security.core.userdetails.UserDetailsService;
 import org.springframework.security.core.userdetails.UsernameNotFoundException;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.stereotype.Service;
 
-import java.util.List;
 import java.util.Optional;
 
 @Service
@@ -48,8 +49,8 @@ public Optional<User> validUsernameAndPassword(String username, String password)
                 .filter(user -> bCryptPasswordEncoder.matches(password, user.getPassword()));
     }
 
-    public List<User> getUserList() {
-        return userRepository.findAll();
+    public Page<User> getUserList(PageRequest pageRequest) {
+        return userRepository.findAll(pageRequest);
     }
 
     public User getUserById(Long id) {

backend/src/main/resources/application.properties

@@ -2,7 +2,7 @@ spring.datasource.url=jdbc:mysql://localhost:3306/claim?useSSL=false
 spring.datasource.username=root
 spring.datasource.password=root
 
-spring.jpa.hibernate.ddl-auto=create
+spring.jpa.hibernate.ddl-auto=update
 spring.mvc.pathmatch.matching-strategy = ANT_PATH_MATCHER
 
 app.cors.allowed-origins= http://localhost:3000