feat(Friend): 친구 CRUD 기능 추가

.gitignore

@@ -223,4 +223,7 @@ gradle-app.setting
 # Java heap dump
 *.hprof
 
+#spring log datas
+logs
+logs/*
 # End of https://www.toptal.com/developers/gitignore/api/windows,macos,intellij+all,visualstudiocode,java,gradle

src/main/java/com/sequence/anonymous/friend/application/FriendService.java

@@ -0,0 +1,91 @@
+package com.sequence.anonymous.friend.application;
+
+import com.google.common.base.Preconditions;
+import com.sequence.anonymous.friend.domain.Friend;
+import com.sequence.anonymous.friend.domain.repository.FriendRepository;
+import com.sequence.anonymous.invite.domain.Invite;
+import com.sequence.anonymous.invite.domain.Kind;
+import com.sequence.anonymous.invite.domain.Status;
+import com.sequence.anonymous.invite.domain.repository.InviteRepository;
+import com.sequence.anonymous.user.domain.repository.UserRepository;
+import com.sequence.anonymous.user.domain.user.User;
+import java.util.List;
+import java.util.Optional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.webjars.NotFoundException;
+
+@Service
+@RequiredArgsConstructor
+public class FriendService {
+
+  private final FriendRepository friendRepository;
+
+  private final UserRepository userRepository;
+
+  private final InviteRepository inviteRepository;
+
+  @Transactional(readOnly = true)
+  public List<Friend> findFriendsByUserId(Long userId) {
+    return friendRepository.findByUserId(userId);
+  }
+
+  @Transactional(readOnly = true)
+  public List<Invite> findRequestsByInviterId(Long inviterId) {
+    return inviteRepository.findByInviterIdAndStatus(inviterId, Status.WAIT);
+  }
+
+  @Transactional(readOnly = true)
+  public List<Invite> findRequestsByInviteeId(Long inviteeId) {
+    return inviteRepository.findByInviteeIdAndStatus(inviteeId, Status.WAIT);
+  }
+
+  @Transactional
+  public void createNewRequest(Long inviterId, Long inviteeId) {
+    Optional<Invite> optionalInvite = inviteRepository.findByInviterIdAndInviteeIdAndStatus(
+        inviterId,
+        inviteeId, Status.WAIT);
+    optionalInvite.ifPresent(invite -> {
+      throw new RuntimeException("duplicate request");
+    });
+
+    Optional<Friend> optionalFriend = friendRepository.findByUserIdAndFriendId(inviterId,
+        inviteeId);
+    optionalFriend.ifPresent(friend -> {
+      throw new RuntimeException("already a friend");
+    });
+
+    User inviter = userRepository.findById(inviterId)
+        .orElseThrow(() -> new NotFoundException("inviter not found"));
+    User invitee = userRepository.findById(inviteeId)
+        .orElseThrow(() -> new NotFoundException("invitee not found"));
+
+    inviteRepository.save(new Invite(inviter, invitee, Kind.FRIEND));
+  }
+
+  @Transactional
+  public void acceptRequest(Long id) {
+    Invite invite = inviteRepository.findById(id)
+        .orElseThrow(() -> new NotFoundException("invite request not found"));
+    Preconditions.checkArgument(invite.getStatus() != Status.DONE, "request has already been processed");
+
+    friendRepository.save(new Friend(invite.getInviter(), invite.getInvitee()));
+    friendRepository.save(new Friend(invite.getInvitee(), invite.getInviter()));
+    invite.markAsDone();
+  }
+
+  @Transactional
+  public void dismissRequest(Long id) {
+    Invite invite = inviteRepository.findById(id)
+        .orElseThrow(() -> new NotFoundException("invite request not found"));
+    Preconditions.checkArgument(invite.getStatus() != Status.DONE, "request has already been processed");
+
+    invite.markAsDone();
+  }
+
+  @Transactional
+  public void deleteById(Long id) {
+    friendRepository.deleteById(id);
+  }
+}

src/main/java/com/sequence/anonymous/friend/domain/Friend.java

@@ -0,0 +1,42 @@
+package com.sequence.anonymous.friend.domain;
+
+import com.google.common.base.Preconditions;
+import com.sequence.anonymous.user.domain.user.User;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Friend {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  private Long id;
+
+  @ManyToOne
+  @JoinColumn(name = "user_id")
+  private User user;
+
+  @ManyToOne
+  @JoinColumn(name = "friend_id")
+  private User friend;
+
+  public Friend(User user, User friend) {
+    Preconditions.checkArgument(user != null, "user must be provided");
+    Preconditions.checkArgument(friend != null, "friend must be provided");
+
+    this.user = user;
+    this.friend = friend;
+  }
+}

src/main/java/com/sequence/anonymous/friend/domain/repository/FriendRepository.java

@@ -0,0 +1,19 @@
+package com.sequence.anonymous.friend.domain.repository;
+
+import com.sequence.anonymous.friend.domain.Friend;
+import com.sequence.anonymous.user.domain.user.User;
+import jakarta.persistence.criteria.From;
+import java.util.Formattable;
+import java.util.List;
+import java.util.Optional;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface FriendRepository extends JpaRepository<Friend, Long> {
+
+  List<Friend> findByUserId(Long userId);
+
+  Optional<Friend> findByUserIdAndFriendId(Long userId, Long friendId);
+}

src/main/java/com/sequence/anonymous/friend/presentation/FriendController.java

@@ -0,0 +1,84 @@
+package com.sequence.anonymous.friend.presentation;
+
+import com.sequence.anonymous.friend.application.FriendService;
+import com.sequence.anonymous.friend.domain.Friend;
+import com.sequence.anonymous.friend.presentation.dto.FriendResponse;
+import com.sequence.anonymous.invite.domain.Invite;
+import com.sequence.anonymous.invite.presentation.dto.InviteResponse;
+import com.sequence.anonymous.security.CustomOAuth2User;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/users/friends")
+public class FriendController {
+
+  private final FriendService friendService;
+
+  @GetMapping("")
+  public ResponseEntity<List<FriendResponse>> findAllFriends(
+      @AuthenticationPrincipal CustomOAuth2User user) {
+    Long userId = user.getId();
+
+    List<Friend> friendList = friendService.findFriendsByUserId(userId);
+    List<FriendResponse> friendResponseList = friendList.stream()
+        .map(FriendResponse::fromFriend)
+        .toList();
+    return ResponseEntity.ok(friendResponseList);
+  }
+
+  @DeleteMapping("/{id}")
+  public ResponseEntity<Void> deleteFriend(@PathVariable Long id) {
+    friendService.deleteById(id);
+    return ResponseEntity.ok().build();
+  }
+
+  @PostMapping("/invites/{id}/accept")
+  public ResponseEntity<Void> acceptRequest(@PathVariable Long id) {
+    friendService.acceptRequest(id);
+    return ResponseEntity.ok().build();
+  }
+
+  @PostMapping("/invites/{id}/dismiss")
+  public ResponseEntity<Void> dismissRequest(@PathVariable Long id) {
+    friendService.dismissRequest(id);
+    return ResponseEntity.ok().build();
+  }
+
+  @PostMapping("/{id}/invitation")
+  public ResponseEntity<Void> createNewRequest(@PathVariable Long id,
+      @AuthenticationPrincipal CustomOAuth2User user) {
+    Long userId = user.getId();
+
+    friendService.createNewRequest(userId, id);
+    return ResponseEntity.ok().build();
+  }
+
+  @GetMapping("/invites")
+  public ResponseEntity<List<InviteResponse>> findAllRequests(
+      @AuthenticationPrincipal CustomOAuth2User user, @RequestParam RequestType type) {
+    Long userId = user.getId();
+    List<Invite> inviteList;
+
+    switch (type) {
+      case SENT -> inviteList = friendService.findRequestsByInviterId(userId);
+      case RECEIVED -> inviteList = friendService.findRequestsByInviteeId(userId);
+      default -> throw new IllegalArgumentException("invalid request type: " + type.toString());
+    }
+
+    List<InviteResponse> inviteResponseList = inviteList.stream()
+        .map(InviteResponse::fromInvite)
+        .toList();
+    return ResponseEntity.ok(inviteResponseList);
+  }
+}

src/main/java/com/sequence/anonymous/friend/presentation/RequestType.java

@@ -0,0 +1,5 @@
+package com.sequence.anonymous.friend.presentation;
+
+public enum RequestType {
+  SENT, RECEIVED
+}

src/main/java/com/sequence/anonymous/friend/presentation/dto/FriendResponse.java

@@ -0,0 +1,18 @@
+package com.sequence.anonymous.friend.presentation.dto;
+
+import com.google.common.base.Preconditions;
+import com.sequence.anonymous.friend.domain.Friend;
+import com.sequence.anonymous.user.domain.user.User;
+
+public record FriendResponse (Long id, User friend) {
+
+  public FriendResponse {
+    Preconditions.checkArgument(friend != null, "friend must be provided");
+  }
+
+  public static FriendResponse fromFriend(Friend friend) {
+    Preconditions.checkArgument(friend != null, "friend must be provided");
+
+    return new FriendResponse(friend.getId(), friend.getFriend());
+  }
+}

src/main/java/com/sequence/anonymous/invite/domain/Invite.java

@@ -0,0 +1,63 @@
+package com.sequence.anonymous.invite.domain;
+
+import com.google.common.base.Preconditions;
+import com.sequence.anonymous.user.domain.user.User;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Invite {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.IDENTITY)
+  private Long id;
+
+  @ManyToOne
+  @JoinColumn(name = "inviter_id")
+  private User inviter;
+
+  @ManyToOne
+  @JoinColumn(name = "invitee_id")
+  private User invitee;
+
+  @Enumerated(EnumType.STRING)
+  @Column(length = 15)
+  private Kind kind;
+
+  @Enumerated(EnumType.STRING)
+  @Column(length = 10)
+  private Status status;
+
+  public Invite(User inviter, User invitee, Kind kind) {
+    this(inviter, invitee, kind, Status.WAIT);
+  }
+
+  private Invite(User inviter, User invitee, Kind kind, Status status) {
+    Preconditions.checkArgument(inviter != null, "inviter must be provided");
+    Preconditions.checkArgument(invitee != null, "invitee must be provided");
+    Preconditions.checkArgument(kind != null, "kind must be provided");
+    Preconditions.checkArgument(status != null, "status must be provided");
+    Preconditions.checkArgument(status != Status.DONE, "initial value of status cannot be DONE");
+
+    this.inviter = inviter;
+    this.invitee = invitee;
+    this.kind = kind;
+    this.status = status;
+  }
+
+  public void markAsDone() {
+    this.status = Status.DONE;
+  }
+}

src/main/java/com/sequence/anonymous/invite/domain/Kind.java

@@ -0,0 +1,5 @@
+package com.sequence.anonymous.invite.domain;
+
+public enum Kind {
+  MATCH_POST, FRIEND
+}

src/main/java/com/sequence/anonymous/invite/domain/Status.java

@@ -0,0 +1,5 @@
+package com.sequence.anonymous.invite.domain;
+
+public enum Status {
+  WAIT, DONE
+}

src/main/java/com/sequence/anonymous/invite/domain/repository/InviteRepository.java

@@ -0,0 +1,19 @@
+package com.sequence.anonymous.invite.domain.repository;
+
+import com.sequence.anonymous.invite.domain.Invite;
+import com.sequence.anonymous.invite.domain.Status;
+import java.util.List;
+import java.util.Optional;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface InviteRepository extends JpaRepository<Invite, Long> {
+
+  List<Invite> findByInviterIdAndStatus(Long inviterId, Status status);
+
+  List<Invite> findByInviteeIdAndStatus(Long inviteeId, Status status);
+
+  Optional<Invite> findByInviterIdAndInviteeIdAndStatus(Long inviterId, Long inviteeId, Status status);
+
+}

src/main/java/com/sequence/anonymous/invite/presentation/dto/InviteResponse.java

@@ -0,0 +1,25 @@
+package com.sequence.anonymous.invite.presentation.dto;
+
+import com.google.common.base.Preconditions;
+import com.sequence.anonymous.invite.domain.Invite;
+import com.sequence.anonymous.invite.domain.Kind;
+import com.sequence.anonymous.invite.domain.Status;
+import com.sequence.anonymous.user.domain.user.User;
+
+public record InviteResponse (Long id, User inviter, User invitee, Kind kind, Status status){
+
+  public InviteResponse {
+    Preconditions.checkArgument(id != null, "id must be provided");
+    Preconditions.checkArgument(inviter!=null, "inviter must be provided");
+    Preconditions.checkArgument(invitee!=null, "invitee must be provided");
+    Preconditions.checkArgument(kind!=null, "kind must be provided");
+    Preconditions.checkArgument(status != null, "status must be provided");
+  }
+
+  public static InviteResponse fromInvite(Invite invite) {
+    Preconditions.checkArgument(invite != null);
+
+    return new InviteResponse(invite.getId(), invite.getInviter(), invite.getInvitee(), invite.getKind(),
+        invite.getStatus());
+  }
+}