Consolidate user friendship into dto to remove extra api call

Daggerpov · Daggerpov · commit 89b27656715b · 2026-01-28T00:47:55.000-08:00
diff --git a/src/main/java/com/danielagapov/spawn/user/api/UserController.java b/src/main/java/com/danielagapov/spawn/user/api/UserController.java
@@ -91,14 +91,24 @@ public ResponseEntity<List<MinimalFriendDTO>> getUserFriendsMinimal(@PathVariabl
     }
 
     // full path: /api/v1/users/{id}
+    // Optional query parameter: requestingUserId - when provided, includes relationship status in response
     @GetMapping("{id}")
-    public ResponseEntity<BaseUserDTO> getUser(@PathVariable UUID id) {
+    public ResponseEntity<BaseUserDTO> getUser(
+            @PathVariable UUID id,
+            @RequestParam(required = false) UUID requestingUserId) {
         if (id == null) {
             logger.error("Invalid parameter: user ID is null");
             return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
         }
         try {
-            return new ResponseEntity<>(userService.getBaseUserById(id), HttpStatus.OK);
+            BaseUserDTO user;
+            if (requestingUserId != null) {
+                // Include relationship status when requestingUserId is provided
+                user = userService.getBaseUserByIdWithRelationship(id, requestingUserId);
+            } else {
+                user = userService.getBaseUserById(id);
+            }
+            return new ResponseEntity<>(user, HttpStatus.OK);
         } catch (BaseNotFoundException e) {
             logger.error("User not found: " + LoggingUtils.formatUserIdInfo(id) + ": " + e.getMessage());
             return new ResponseEntity<>(HttpStatus.NOT_FOUND);
@@ -281,6 +291,10 @@ public ResponseEntity<List<RecentlySpawnedUserDTO>> getRecentlySpawnedWithUsers(
     }
 
     // full path: /api/v1/users/{userId}/is-friend/{potentialFriendId}
+    // @deprecated Use GET /api/v1/users/{id}?requestingUserId={requestingUserId} instead.
+    // The user endpoint now returns relationshipStatus and pendingFriendRequestId fields
+    // when requestingUserId is provided, eliminating the need for this separate endpoint.
+    @Deprecated(since = "1.0", forRemoval = true)
     @GetMapping("{userId}/is-friend/{potentialFriendId}")
     public ResponseEntity<Boolean> isUserFriendOfUser(
             @PathVariable UUID userId,
diff --git a/src/main/java/com/danielagapov/spawn/user/api/dto/BaseUserDTO.java b/src/main/java/com/danielagapov/spawn/user/api/dto/BaseUserDTO.java
@@ -1,5 +1,6 @@
 package com.danielagapov.spawn.user.api.dto;
 
+import com.danielagapov.spawn.shared.util.UserRelationshipType;
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.Getter;
@@ -15,19 +16,25 @@ public class BaseUserDTO extends AbstractUserDTO {
     private String profilePicture;
     private Boolean hasCompletedOnboarding;
     private String provider;  // Auth provider: "google", "apple", or "email"
+    private UserRelationshipType relationshipStatus;  // Relationship status relative to requesting user
+    private UUID pendingFriendRequestId;  // ID of pending friend request if one exists
 
     public BaseUserDTO(UUID id, String name, String email, String username, String bio, String profilePicture) {
         super(id, name, email, username, bio);
         this.profilePicture = profilePicture;
         this.hasCompletedOnboarding = false; // Default value for backward compatibility
         this.provider = null;
+        this.relationshipStatus = null;
+        this.pendingFriendRequestId = null;
     }
 
     public BaseUserDTO(UUID id, String name, String email, String username, String bio, String profilePicture, Boolean hasCompletedOnboarding) {
         super(id, name, email, username, bio);
         this.profilePicture = profilePicture;
         this.hasCompletedOnboarding = hasCompletedOnboarding != null ? hasCompletedOnboarding : false;
         this.provider = null;
+        this.relationshipStatus = null;
+        this.pendingFriendRequestId = null;
     }
 
     @JsonCreator
@@ -39,10 +46,32 @@ public BaseUserDTO(
             @JsonProperty("bio") String bio, 
             @JsonProperty("profilePicture") String profilePicture, 
             @JsonProperty("hasCompletedOnboarding") Boolean hasCompletedOnboarding,
-            @JsonProperty("provider") String provider) {
+            @JsonProperty("provider") String provider,
+            @JsonProperty("relationshipStatus") UserRelationshipType relationshipStatus,
+            @JsonProperty("pendingFriendRequestId") UUID pendingFriendRequestId) {
         super(id, name, email, username, bio);
         this.profilePicture = profilePicture;
         this.hasCompletedOnboarding = hasCompletedOnboarding != null ? hasCompletedOnboarding : false;
         this.provider = provider;
+        this.relationshipStatus = relationshipStatus;
+        this.pendingFriendRequestId = pendingFriendRequestId;
+    }
+
+    // Backward-compatible constructor (without relationship fields)
+    public BaseUserDTO(
+            UUID id, 
+            String name, 
+            String email, 
+            String username, 
+            String bio, 
+            String profilePicture, 
+            Boolean hasCompletedOnboarding,
+            String provider) {
+        super(id, name, email, username, bio);
+        this.profilePicture = profilePicture;
+        this.hasCompletedOnboarding = hasCompletedOnboarding != null ? hasCompletedOnboarding : false;
+        this.provider = provider;
+        this.relationshipStatus = null;
+        this.pendingFriendRequestId = null;
     }
 }
diff --git a/src/main/java/com/danielagapov/spawn/user/internal/services/IUserService.java b/src/main/java/com/danielagapov/spawn/user/internal/services/IUserService.java
@@ -240,6 +240,18 @@ public interface IUserService {
      */
     BaseUserDTO getBaseUserById(UUID id);
 
+    /**
+     * Retrieves a user as a BaseUserDTO by their unique identifier with relationship status.
+     * When a requestingUserId is provided, the returned DTO includes the relationship status
+     * between the requesting user and the target user.
+     *
+     * @param id the unique identifier of the user to retrieve
+     * @param requestingUserId the unique identifier of the user making the request (optional)
+     * @return BaseUserDTO object with relationship status if requestingUserId is provided
+     * @throws com.danielagapov.spawn.Exceptions.Base.BaseNotFoundException if user doesn't exist
+     */
+    BaseUserDTO getBaseUserByIdWithRelationship(UUID id, UUID requestingUserId);
+
     /**
      * Updates a user's information with the provided update data.
      *
diff --git a/src/main/java/com/danielagapov/spawn/user/internal/services/UserService.java b/src/main/java/com/danielagapov/spawn/user/internal/services/UserService.java
@@ -6,13 +6,16 @@
 import com.danielagapov.spawn.user.api.dto.FriendUser.RecommendedFriendUserDTO;
 import com.danielagapov.spawn.user.api.dto.Profile.UserProfileInfoDTO;
 import com.danielagapov.spawn.shared.util.EntityType;
+import com.danielagapov.spawn.shared.util.UserRelationshipType;
 import com.danielagapov.spawn.shared.util.UserStatus;
 import com.danielagapov.spawn.shared.exceptions.Base.BaseNotFoundException;
 import com.danielagapov.spawn.shared.exceptions.Base.BaseSaveException;
 import com.danielagapov.spawn.shared.exceptions.Base.BasesNotFoundException;
 import com.danielagapov.spawn.shared.exceptions.Logger.ILogger;
 import com.danielagapov.spawn.shared.util.UserMapper;
+import com.danielagapov.spawn.social.api.dto.CreateFriendRequestDTO;
 import com.danielagapov.spawn.social.internal.domain.Friendship;
+import com.danielagapov.spawn.social.internal.services.IFriendRequestService;
 import com.danielagapov.spawn.user.internal.domain.User;
 import com.danielagapov.spawn.social.internal.repositories.IFriendshipRepository;
 import com.danielagapov.spawn.auth.internal.repositories.IUserIdExternalIdMapRepository;
@@ -46,6 +49,7 @@ public class UserService implements IUserService {
     private final ILogger logger;
     private final IUserSearchQueryService userSearchQueryService;
     private final IUserFriendshipQueryService friendshipQueryService;
+    private final IFriendRequestService friendRequestService;
     private final CacheManager cacheManager;
     private final ApplicationEventPublisher eventPublisher;
     private final IUserIdExternalIdMapRepository userIdExternalIdMapRepository;
@@ -59,6 +63,7 @@ public UserService(IUserRepository repository,
                        IS3Service s3Service, ILogger logger,
                        IUserSearchQueryService userSearchQueryService,
                        IUserFriendshipQueryService friendshipQueryService,
+                       IFriendRequestService friendRequestService,
                        CacheManager cacheManager,
                        ApplicationEventPublisher eventPublisher,
                        IUserIdExternalIdMapRepository userIdExternalIdMapRepository) {
@@ -68,6 +73,7 @@ public UserService(IUserRepository repository,
         this.logger = logger;
         this.userSearchQueryService = userSearchQueryService;
         this.friendshipQueryService = friendshipQueryService;
+        this.friendRequestService = friendRequestService;
         this.cacheManager = cacheManager;
         this.eventPublisher = eventPublisher;
         this.userIdExternalIdMapRepository = userIdExternalIdMapRepository;
@@ -434,6 +440,112 @@ public BaseUserDTO getBaseUserById(UUID id) {
         }
     }
 
+    @Override
+    public BaseUserDTO getBaseUserByIdWithRelationship(UUID id, UUID requestingUserId) {
+        try {
+            User user = repository.findById(id)
+                    .orElseThrow(() -> new BaseNotFoundException(EntityType.User, id));
+
+            // Hide admin user from front-end
+            if (isAdminUser(user)) {
+                throw new BaseNotFoundException(EntityType.User, id);
+            }
+
+            BaseUserDTO dto = UserMapper.toDTO(user);
+            
+            // If requestingUserId is provided and different from the target user, determine relationship
+            if (requestingUserId != null && !requestingUserId.equals(id)) {
+                UserRelationshipType relationshipStatus = determineRelationshipStatus(requestingUserId, id);
+                dto.setRelationshipStatus(relationshipStatus);
+                
+                // Get pending friend request ID if applicable
+                UUID pendingRequestId = getPendingFriendRequestId(requestingUserId, id, relationshipStatus);
+                dto.setPendingFriendRequestId(pendingRequestId);
+            }
+            
+            return dto;
+        } catch (Exception e) {
+            logger.error("Error getting user with relationship: " + LoggingUtils.formatUserIdInfo(id) + ": " + e.getMessage());
+            throw e;
+        }
+    }
+
+    /**
+     * Determines the relationship status between the requesting user and a target user.
+     * 
+     * @param requestingUserId The ID of the user making the request
+     * @param targetUserId The ID of the target user
+     * @return UserRelationshipType representing the current relationship status
+     */
+    private UserRelationshipType determineRelationshipStatus(UUID requestingUserId, UUID targetUserId) {
+        try {
+            // Check if they are already friends
+            if (friendshipQueryService.isUserFriendOfUser(requestingUserId, targetUserId)) {
+                return UserRelationshipType.FRIEND;
+            }
+            
+            // Check for outgoing friend request (requesting user sent to target user)
+            List<CreateFriendRequestDTO> outgoingRequests = friendRequestService.getSentFriendRequestsByUserId(requestingUserId);
+            boolean hasOutgoingRequest = outgoingRequests.stream()
+                    .anyMatch(request -> request.getReceiverUserId().equals(targetUserId));
+            
+            if (hasOutgoingRequest) {
+                return UserRelationshipType.OUTGOING_FRIEND_REQUEST;
+            }
+            
+            // Check for incoming friend request (target user sent to requesting user)
+            List<CreateFriendRequestDTO> incomingRequests = friendRequestService.getIncomingCreateFriendRequestsByUserId(requestingUserId);
+            boolean hasIncomingRequest = incomingRequests.stream()
+                    .anyMatch(request -> request.getSenderUserId().equals(targetUserId));
+            
+            if (hasIncomingRequest) {
+                return UserRelationshipType.INCOMING_FRIEND_REQUEST;
+            }
+            
+            // Default to recommended friend if no existing relationship
+            return UserRelationshipType.RECOMMENDED_FRIEND;
+            
+        } catch (Exception e) {
+            logger.error("Error determining relationship status between users " + requestingUserId + " and " + targetUserId + ": " + e.getMessage());
+            return UserRelationshipType.RECOMMENDED_FRIEND;
+        }
+    }
+    
+    /**
+     * Gets the pending friend request ID if there is one between the users.
+     * 
+     * @param requestingUserId The ID of the user making the request
+     * @param targetUserId The ID of the target user
+     * @param relationshipStatus The current relationship status
+     * @return UUID of the pending friend request, or null if none exists
+     */
+    private UUID getPendingFriendRequestId(UUID requestingUserId, UUID targetUserId, UserRelationshipType relationshipStatus) {
+        try {
+            if (relationshipStatus == UserRelationshipType.OUTGOING_FRIEND_REQUEST) {
+                // Find the outgoing request ID
+                List<CreateFriendRequestDTO> outgoingRequests = friendRequestService.getSentFriendRequestsByUserId(requestingUserId);
+                return outgoingRequests.stream()
+                        .filter(request -> request.getReceiverUserId().equals(targetUserId))
+                        .map(CreateFriendRequestDTO::getId)
+                        .findFirst()
+                        .orElse(null);
+            } else if (relationshipStatus == UserRelationshipType.INCOMING_FRIEND_REQUEST) {
+                // Find the incoming request ID
+                List<CreateFriendRequestDTO> incomingRequests = friendRequestService.getIncomingCreateFriendRequestsByUserId(requestingUserId);
+                return incomingRequests.stream()
+                        .filter(request -> request.getSenderUserId().equals(targetUserId))
+                        .map(CreateFriendRequestDTO::getId)
+                        .findFirst()
+                        .orElse(null);
+            }
+            
+            return null;
+        } catch (Exception e) {
+            logger.error("Error getting pending friend request ID between users " + requestingUserId + " and " + targetUserId + ": " + e.getMessage());
+            return null;
+        }
+    }
+
     @Override
     public BaseUserDTO updateUser(UUID id, UserUpdateDTO updateDTO) {
         try {
