[RI-23]: modifie la recherche de tous les utilisateurs pour ne plus a…

…voir à récupérer la liste de toutes les relations (#82)

 * introduction d'une enum TypeRelation dans le UserDto pour introduire la notion de SENDER, RECEIVER, FRIEND dans le cadre d'une relation

backend-implicaction/src/main/java/com/dynonuggets/refonteimplicaction/config/SecurityConfig.java

@@ -50,7 +50,6 @@ protected void configure(HttpSecurity httpSecurity) throws Exception {
         httpSecurity.cors().disable()
                 .csrf().disable()
                 .authorizeRequests()
-                // désactive l'authentification pour les requêtes dont l'url commence par /api/auth/
                 .antMatchers(AUTH_WHITELIST)
                 .permitAll()
                 .anyRequest()

backend-implicaction/src/main/java/com/dynonuggets/refonteimplicaction/controller/RelationController.java

@@ -8,8 +8,6 @@
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.List;
-
 
 @RestController
 @AllArgsConstructor
@@ -26,12 +24,6 @@ public ResponseEntity<RelationsDto> requestRelation(@PathVariable("receiverId")
         return ResponseEntity.ok(relationsDto);
     }
 
-    @GetMapping(value = "/list/{userId}")
-    public ResponseEntity<List<RelationsDto>> getAllForUserId(@PathVariable("userId") Long userId) {
-        List<RelationsDto> relations = relationService.getAllForUserId(userId);
-        return ResponseEntity.ok(relations);
-    }
-
     @SuppressWarnings("rawtypes")
     @DeleteMapping(value = "/{senderId}/decline")
     public ResponseEntity deleteRelationBySender(@PathVariable("senderId") Long senderId) {

backend-implicaction/src/main/java/com/dynonuggets/refonteimplicaction/controller/UserController.java

@@ -30,7 +30,7 @@ public ResponseEntity<Page<UserDto>> getAll(
             @RequestParam(value = "size", defaultValue = "10") int size
     ) {
         Pageable pageable = PageRequest.of(page, size);
-        Page<UserDto> users = userService.getAll(pageable);
+        Page<UserDto> users = userService.getAll(pageable, true);
         return ResponseEntity.ok(users);
     }
 
@@ -47,7 +47,7 @@ public ResponseEntity<Page<UserDto>> getAllFriends(
             @PathVariable("userId") Long userId
     ) {
         Pageable pageable = PageRequest.of(page, size);
-        Page<UserDto> userDtos = relationService.getAllFriendsByUserId(pageable, userId);
+        Page<UserDto> userDtos = relationService.getAllFriendsByUserId(userId, pageable);
         return ResponseEntity.ok(userDtos);
     }
 
@@ -69,7 +69,7 @@ public ResponseEntity<Page<UserDto>> getReceivedFriendRequest(
     ) {
         Pageable pageable = PageRequest.of(page, size);
         Long userId = authService.getCurrentUser().getId();
-        Page<UserDto> usersDto = relationService.getReceivedFriendRequest(userId ,pageable);
+        Page<UserDto> usersDto = relationService.getReceivedFriendRequest(userId, pageable);
         return ResponseEntity.ok(usersDto);
     }
 }

backend-implicaction/src/main/java/com/dynonuggets/refonteimplicaction/dto/RelationTypeEnum.java

@@ -0,0 +1,5 @@
+package com.dynonuggets.refonteimplicaction.dto;
+
+public enum RelationTypeEnum {
+    FRIEND, RECEIVER, SENDER, NONE
+}

backend-implicaction/src/main/java/com/dynonuggets/refonteimplicaction/dto/UserDto.java

@@ -33,5 +33,5 @@ public class UserDto {
     private String contribution;
     private String firstName;
     private String lastName;
-
+    private RelationTypeEnum relationTypeOfCurrentUser;
 }

backend-implicaction/src/main/java/com/dynonuggets/refonteimplicaction/repository/RelationRepository.java

@@ -38,4 +38,14 @@ public interface RelationRepository extends JpaRepository<Relation, Long> {
             "from Relation r " +
             "where (r.sender.id = ?1 and r.receiver.id = ?2) or (r.sender.id = ?2 and r.receiver.id = ?1)")
     Optional<Relation> findRelationBetween(Long userId1, Long userId2);
+
+    @Query("select r " +
+            "from Relation r " +
+            "where r.sender.id in ?1 or r.receiver.id in ?1")
+    List<Relation> findAllByUserIdIn(List<Long> userIds);
+
+    @Query("select r " +
+            "from Relation r " +
+            "where (r.sender.id in ?2 and r.receiver.id = ?1) or (r.receiver.id in ?2 and r.sender.id = ?1)")
+    List<Relation> findAllRelatedToUserByUserIdIn(Long userId, List<Long> userIds);
 }

backend-implicaction/src/main/java/com/dynonuggets/refonteimplicaction/service/AuthService.java

@@ -27,7 +27,6 @@ public class AuthService {
 
     private final PasswordEncoder passwordEncoder;
     private final UserRepository userRepository;
-    private final UserService userService;
     private final SignUpRepository signUpRepository;
     private final MailService mailService;
     private final AuthenticationManager authenticationManager;
@@ -78,7 +77,8 @@ public AuthenticationResponseDto login(LoginRequestDto loginRequestDto) throws I
         Instant expiresAt = Instant.now().plusMillis(jwtProvider.getJwtExpirationInMillis());
         String refreshToken = refreshTokenService.generateRefreshToken().getToken();
 
-        final UserDto user = userService.getUserByUsername(username);
+        final User user = userRepository.findByUsername(username)
+                .orElseThrow(() -> new UsernameNotFoundException("Username " + username + " not found."));
 
         return AuthenticationResponseDto.builder()
                 .authenticationToken(token)
@@ -100,7 +100,8 @@ public UserDto getCurrentUser() {
 
     public AuthenticationResponseDto refreshToken(RefreshTokenRequestDto refreshTokenRequestDto) throws ImplicactionException {
         final String username = refreshTokenRequestDto.getUsername();
-        final UserDto user = userService.getUserByUsername(username);
+        final User user = userRepository.findByUsername(username)
+                .orElseThrow(() -> new UsernameNotFoundException("Username " + username + " not found."));
 
         refreshTokenService.validateRefreshToken(refreshTokenRequestDto.getRefreshToken());
         String token = jwtProvider.generateTokenWithUsername(username);

backend-implicaction/src/main/java/com/dynonuggets/refonteimplicaction/service/RelationService.java

@@ -17,9 +17,8 @@
 import org.springframework.stereotype.Service;
 
 import java.time.Instant;
-import java.util.List;
 
-import static java.util.stream.Collectors.toList;
+import static com.dynonuggets.refonteimplicaction.dto.RelationTypeEnum.*;
 
 @Service
 @AllArgsConstructor
@@ -29,8 +28,14 @@ public class RelationService {
     private final RelationRepository relationRepository;
     private final RelationAdapter relationAdapter;
     private final UserAdapter userAdapter;
-    private final UserService userService;
 
+    /**
+     * Crée une nouvelle relation entre le senderId et le receiverId
+     *
+     * @return la nouvelle relation créée avec confirmedAt à null
+     * @throws UserNotFoundException si l'un des deux utilisateurs au moins n'existe pas
+     * @throws ImplicactionException si sender et receiver correspondent au même utilisateur
+     */
     public RelationsDto requestRelation(Long senderId, Long receiverId) {
         // TODO: gérer avec une exception plus appropriée
         if (senderId.equals(receiverId)) {
@@ -55,15 +60,10 @@ public RelationsDto requestRelation(Long senderId, Long receiverId) {
         return relationAdapter.toDto(save);
     }
 
-    public List<RelationsDto> getAllForUserId(Long userId) {
-        final List<Relation> relations = relationRepository.findAllByUserId(userId);
-        return relations.stream()
-                .map(relationAdapter::toDto)
-                .collect(toList());
-    }
-
     /**
      * Supprime la relation entre le sender et le receiver dont les ids sont passé en paramètres
+     *
+     * @throws NotFoundException si l'un des deux utilisateurs au moins n'existe pas
      */
     public void deleteRelation(Long senderId, Long receiverId) {
         Relation relation = relationRepository.findBySender_IdAndReceiver_Id(senderId, receiverId)
@@ -74,6 +74,8 @@ public void deleteRelation(Long senderId, Long receiverId) {
     /**
      * Supprime la relation entre les utilisateurs dont les ids sont passés en paramètres, sans tenir compte de la notion
      * de sender / receiver
+     *
+     * @throws NotFoundException si l'un des deux utilisateurs au moins n'existe pas
      */
     public void cancelRelation(Long userId1, Long userId2) {
         Relation relation = relationRepository.findRelationBetween(userId1, userId2)
@@ -82,8 +84,10 @@ public void cancelRelation(Long userId1, Long userId2) {
     }
 
     /**
-     * Confirme la relation entre les utilisateurs dont les ids sont passés en paramètres, en tenant compte de la notion
-     * de sender / receiver
+     * Confirme la relation entre les utilisateurs dont les ids sont passés en paramètres
+     *
+     * @return la relation entre senderId et receiverId
+     * @throws NotFoundException si l'un des deux utilisateurs au moins n'existe pas
      */
     public RelationsDto confirmRelation(Long senderId, Long receiverId) {
         Relation relation = relationRepository.findBySender_IdAndReceiver_Id(senderId, receiverId)
@@ -94,28 +98,39 @@ public RelationsDto confirmRelation(Long senderId, Long receiverId) {
     }
 
     /**
-     * Renvoie tous les utilisateurs qui sont amis avec l'utilisateur en paramètres
+     * @return tous les utilisateurs qui sont amis avec userId
      */
-    public Page<UserDto> getAllFriendsByUserId(Pageable pageable, Long userId) {
-        // renvoie une exception si l'utilisateur n'existe pas
-        userService.getUserById(userId);
+    public Page<UserDto> getAllFriendsByUserId(Long userId, Pageable pageable) {
         Page<Relation> relations = relationRepository.findAllFriendsByUserId(userId, pageable);
-
         return relations.map(relation -> {
-            if (relation.getSender().getId().equals(userId)) {
-                return userAdapter.toDto(relation.getReceiver());
-            }
-            return userAdapter.toDto(relation.getSender());
+            final User friend = userId.equals(relation.getReceiver().getId()) ? relation.getSender() : relation.getReceiver();
+            final UserDto userDto = userAdapter.toDto(friend);
+            userDto.setRelationTypeOfCurrentUser(FRIEND);
+            return userDto;
         });
     }
 
+    /**
+     * @return tous les utilisateurs à qui userId a envoyé une demande d'ami qui n'a pas encore été confirmée
+     */
     public Page<UserDto> getSentFriendRequest(Long userId, Pageable pageable) {
         Page<Relation> relations = relationRepository.findAllBySender_IdAndConfirmedAtIsNull(userId, pageable);
-        return relations.map(relation -> userAdapter.toDto(relation.getReceiver()));
+        return relations.map(relation -> {
+            final UserDto userDto = userAdapter.toDto(relation.getReceiver());
+            userDto.setRelationTypeOfCurrentUser(SENDER);
+            return userDto;
+        });
     }
 
+    /**
+     * @return tous les utilisateurs qui ont envoyé une demande d'ami à userId
+     */
     public Page<UserDto> getReceivedFriendRequest(Long userId, Pageable pageable) {
         Page<Relation> relations = relationRepository.findAllByReceiver_IdAndConfirmedAtIsNull(userId, pageable);
-        return relations.map(relation -> userAdapter.toDto(relation.getSender()));
+        return relations.map(relation -> {
+            final UserDto userDto = userAdapter.toDto(relation.getSender());
+            userDto.setRelationTypeOfCurrentUser(RECEIVER);
+            return userDto;
+        });
     }
 }

backend-implicaction/src/main/java/com/dynonuggets/refonteimplicaction/service/UserService.java

@@ -1,27 +1,55 @@
 package com.dynonuggets.refonteimplicaction.service;
 
 import com.dynonuggets.refonteimplicaction.adapter.UserAdapter;
+import com.dynonuggets.refonteimplicaction.dto.RelationTypeEnum;
 import com.dynonuggets.refonteimplicaction.dto.UserDto;
 import com.dynonuggets.refonteimplicaction.exception.UserNotFoundException;
+import com.dynonuggets.refonteimplicaction.model.Relation;
 import com.dynonuggets.refonteimplicaction.model.User;
+import com.dynonuggets.refonteimplicaction.repository.RelationRepository;
 import com.dynonuggets.refonteimplicaction.repository.UserRepository;
 import lombok.AllArgsConstructor;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.List;
+import java.util.stream.Collectors;
+
 @Service
 @AllArgsConstructor
 public class UserService {
 
     private final UserRepository userRepository;
+    private final RelationRepository relationRepository;
+    private final AuthService authService;
     private final UserAdapter userAdapter;
 
+    /**
+     * @param isCurrentUserRelation recherche les relations avec l'utilisateur courant
+     * @return la liste paginée de tous les utilisateurs
+     */
     @Transactional(readOnly = true)
-    public Page<UserDto> getAll(Pageable pageable) {
-        return userRepository.findAll(pageable)
+    public Page<UserDto> getAll(Pageable pageable, boolean isCurrentUserRelation) {
+        final Long currentUserId = authService.getCurrentUser().getId();
+
+        final Page<UserDto> users = userRepository.findAll(pageable)
                 .map(userAdapter::toDto);
+
+        if (isCurrentUserRelation) {
+            final List<Long> userIds = users.map(UserDto::getId)
+                    .get()
+                    .collect(Collectors.toList());
+            // on recherche les relations de tous les utilisateurs remontés avec l'utilisateur courant ...
+            List<Relation> relations = relationRepository.findAllRelatedToUserByUserIdIn(currentUserId, userIds);
+            // ... et on associe chaque relation avec un statut
+            relations.forEach(relation -> users.stream()
+                    .filter(user -> isSenderOrReceiver(relation, user.getId()) && !currentUserId.equals(user.getId()))
+                    .findFirst()
+                    .ifPresent(user -> user.setRelationTypeOfCurrentUser(getRelationType(relation, currentUserId))));
+        }
+        return users;
     }
 
     public UserDto getUserById(Long userId) {
@@ -30,9 +58,20 @@ public UserDto getUserById(Long userId) {
         return userAdapter.toDto(user);
     }
 
-    public UserDto getUserByUsername(String username) {
-        final User user = userRepository.findByUsername(username)
-                .orElseThrow(() -> new UserNotFoundException("No user found with username " + username));
-        return userAdapter.toDto(user);
+    private boolean isSenderOrReceiver(Relation relation, Long userId) {
+        return userId.equals(relation.getReceiver().getId()) || userId.equals(relation.getSender().getId());
+    }
+
+    private RelationTypeEnum getRelationType(Relation relation, Long userId) {
+        if (relation.getConfirmedAt() != null) {
+            return RelationTypeEnum.FRIEND;
+        }
+        if (userId.equals(relation.getReceiver().getId())) {
+            return RelationTypeEnum.RECEIVER;
+        }
+        if (userId.equals(relation.getSender().getId())) {
+            return RelationTypeEnum.SENDER;
+        }
+        return RelationTypeEnum.NONE;
     }
 }

frontend-implicaction/src/app/shared/models/user.ts

@@ -1,5 +1,6 @@
 import {WorkExperience} from './work-experience';
 import {Training} from './training';
+import {RelationType} from '../../user/models/relation-type.enum';
 
 export interface User {
   id?: string;
@@ -21,4 +22,5 @@ export interface User {
   rank?: string;
   experiences?: WorkExperience[];
   trainings?: Training[];
+  relationTypeOfCurrentUser?: RelationType;
 }

frontend-implicaction/src/app/user/components/user-list/user-list.component.html

@@ -38,7 +38,7 @@
         <app-user-card [user]="user">
           <div class="mt-4 mb-2">
             <!-- CAS 1 : est un ami -->
-            <ng-container *ngIf="isFriend(user); else optionSender">
+            <ng-container *ngIf="user.relationTypeOfCurrentUser === relationType.FRIEND; else optionSender">
               <button
                 (click)="removeUserRelation(user)"
                 class="btn btn-danger text-light rounded-pill"
@@ -52,7 +52,7 @@
             </ng-container>
             <!-- CAS 2 : est à l'origine d'une demande non acceptée -->
             <ng-template #optionSender>
-              <ng-container *ngIf="isSender(user); else optionReceiver">
+              <ng-container *ngIf="user.relationTypeOfCurrentUser === relationType.SENDER; else optionReceiver">
                 <button
                   (click)="removeUserRelation(user)"
                   class="btn btn-danger text-light rounded-pill"
@@ -67,7 +67,7 @@
             </ng-template>
             <!-- CAS 3 : est receveur d'une demande non acceptée -->
             <ng-template #optionReceiver>
-              <ng-container *ngIf="isReceiver(user); else optionNoRelation">
+              <ng-container *ngIf="user.relationTypeOfCurrentUser === relationType.RECEIVER; else optionNoRelation">
                 <button
                   (click)="confirmUserAsFriend(user)"
                   class="btn btn-success rounded-pill mx-2 mx-sm-1"
@@ -108,8 +108,8 @@
       </ng-container>
     </div>
     <p-paginator
-      (onPageChange)="paginate($event)"
       *ngIf="pageable.totalPages > 1"
+      (onPageChange)="paginate($event)"
       [rowsPerPageOptions]="[10, 25, 50]"
       [rows]="rowsPerPage"
       [totalRecords]="pageable.totalElements"