feature: Add endpoint to retrieve all users and refactor user repository usage

#deploy-bruker-service
#deploy-test-bruker-service

Author: krharum

apps/bruker-service/src/main/java/no/nav/testnav/apps/brukerservice/controller/v2/BrukerController.java

@@ -18,6 +18,7 @@
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import java.util.Collections;
@@ -35,17 +36,24 @@ public class BrukerController {
 
     @PostMapping
     public Mono<BrukerDTO> createBruker(
-            @RequestBody BrukerDTO brukerDTO
-    ) {
+            @RequestBody BrukerDTO brukerDTO) {
+
         return validateService.validateOrganiasjonsnummerAccess(brukerDTO.organisasjonsnummer())
                 .then(userService.create(brukerDTO))
                 .map(User::toDTO);
     }
 
+    @GetMapping("/alle")
+    public Flux<BrukerDTO> getAlleBrukere() {
+
+        return userService.getAllUsers()
+                .map(User::toDTO);
+    }
+
     @GetMapping
     public Mono<List<BrukerDTO>> getBrukere(
-            @RequestParam String organisasjonsnummer
-    ) {
+            @RequestParam String organisasjonsnummer) {
+
         return validateService.validateOrganiasjonsnummerAccess(organisasjonsnummer)
                 .then(userService.getUserFromOrganisasjonsnummer(organisasjonsnummer))
                 .map(User::toDTO)
@@ -55,41 +63,42 @@ public Mono<List<BrukerDTO>> getBrukere(
     @GetMapping("/{id}")
     public Mono<BrukerDTO> getBruker(
             @PathVariable String id,
-            @RequestHeader(UserConstant.USER_HEADER_JWT) String jwt
-    ) {
+            @RequestHeader(UserConstant.USER_HEADER_JWT) String jwt) {
+
         return jwtService.verify(jwt, id)
                 .then(userService.getUser(id))
                 .map(User::toDTO);
     }
 
     @PutMapping()
     public Mono<BrukerDTO> updateBruker(
-            @RequestBody BrukerDTO bruker
-    ) {
+            @RequestBody BrukerDTO bruker) {
+
         return validateService.validateOrganiasjonsnummerAccess(bruker.organisasjonsnummer())
                 .then(userService.updateUser(bruker))
                 .map(User::toDTO);
     }
 
     @GetMapping("/brukernavn/{brukernavn}")
     public Mono<String> getBrukernavn(
-            @PathVariable String brukernavn
-    ) {
+            @PathVariable String brukernavn) {
+
         return userService.getUserByBrukernavn(brukernavn)
                 .map(User::getBrukernavn);
     }
 
     @DeleteMapping("/{id}")
     public Mono<Void> deleteBruker(
             @PathVariable String id,
-            @RequestHeader(UserConstant.USER_HEADER_JWT) String jwt
-    ) {
+            @RequestHeader(UserConstant.USER_HEADER_JWT) String jwt) {
+
         return jwtService.verify(jwt, id)
                 .then(userService.delete(id));
     }
 
     @PostMapping("/{id}/token")
     public Mono<String> getToken(@PathVariable String id) {
+
         return userService.getUser(id, true)
                 .doOnNext(user -> validateService.validateOrganiasjonsnummerAccess(user.getOrganisasjonsnummer()))
                 .flatMap(jwtService::getToken);

apps/bruker-service/src/main/java/no/nav/testnav/apps/brukerservice/service/v2/UserService.java

@@ -11,15 +11,17 @@
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 import org.springframework.web.server.ResponseStatusException;
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import java.time.LocalDateTime;
 
 @Service("userServiceV2")
 @RequiredArgsConstructor
 public class UserService {
+
     private final CryptographyService cryptographyService;
-    private final UserRepository repository;
+    private final UserRepository userRepository;
     private final GetAuthenticatedUserId getAuthenticatedUserId;
 
     public Mono<User> create(BrukerDTO bruker) {
@@ -35,7 +37,7 @@ public Mono<User> create(BrukerDTO bruker) {
                     entity.setNew(true);
                     return entity;
                 })
-                .flatMap(repository::save)
+                .flatMap(userRepository::save)
                 .map(User::new);
 
     }
@@ -47,17 +49,22 @@ public Mono<User> getUserFromOrganisasjonsnummer(String organisasjonsnummer) {
                 .flatMap(this::getUser);
     }
 
+    public Flux<User> getAllUsers() {
+
+        return userRepository.findAll()
+                .map(User::new);
+    }
 
     public Mono<User> getUser(String id) {
         return getUser(id, false);
     }
 
     public Mono<User> getUser(String id, boolean loggedIn) {
-        return repository.findById(id).flatMap(entity -> {
+        return userRepository.findById(id).flatMap(entity -> {
             if (loggedIn) {
                 entity.setNew(false);
                 entity.setSistInnlogget(LocalDateTime.now());
-                return repository.save(entity);
+                return userRepository.save(entity);
             }
             return Mono.just(entity);
         }).map(User::new);
@@ -67,26 +74,26 @@ public Mono<User> updateUser(BrukerDTO bruker) {
         return getAuthenticatedUserId
                 .call()
                 .map(userId -> cryptographyService.createId(userId, bruker.organisasjonsnummer()))
-                .flatMap(repository::findById)
+                .flatMap(userRepository::findById)
                 .switchIfEmpty(Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND, "Bruker ikke funnet.")))
                 .flatMap(entity -> {
                     entity.setEpost(bruker.epost());
-                    return repository.save(entity);
+                    return userRepository.save(entity);
                 })
                 .map(User::new);
     }
 
     public Mono<User> getUserByBrukernavn(String username) {
-        return repository.findByBrukernavn(username).map(User::new);
+        return userRepository.findByBrukernavn(username).map(User::new);
     }
 
     public Mono<Void> delete(String id) {
-        return repository.deleteById(id);
+        return userRepository.deleteById(id);
     }
 
     private Mono<Void> validateCreateUser(String userId, String representing) {
         var id = cryptographyService.createId(userId, representing);
-        return repository.existsById(id)
+        return userRepository.existsById(id)
                 .doOnNext(exists -> {
                     if (Boolean.TRUE.equals(exists)) {
                         throw new UserAlreadyExistsException(id);