[BE] Member 관련 기능 개발

backend/src/docs/asciidoc/index.adoc

@@ -10,3 +10,4 @@ toc::[]
 
 include::topic.adoc[]
 include::pin.adoc[]
+include::member.adoc[]

backend/src/docs/asciidoc/member.adoc

@@ -0,0 +1,37 @@
+== 유저
+
+=== 유저 권한 부여
+
+operation::member-controller-test/add-member-topic-permission[snippets='http-request,http-response']
+
+=== 유저 권한 삭제
+
+operation::member-controller-test/delete-member-topic-permission[snippets='http-request,http-response']
+
+=== 토픽에 권한을 가진 유저 목록 조회
+
+operation::member-controller-test/find-member-topic-permission-all[snippets='http-request,http-response']
+
+=== 토픽에 권한을 가진 유저 단일 조회
+
+operation::member-controller-test/find-member-topic-permission-by-id[snippets='http-request,http-response']
+
+=== 유저 생성
+
+operation::member-controller-test/add[snippets='http-request,http-response']
+
+=== 유저 목록 조회
+
+operation::member-controller-test/find-all-member[snippets='http-request,http-response']
+
+=== 유저 단일 조회
+
+operation::member-controller-test/find-member-by-id[snippets='http-request,http-response']
+
+=== 유저가 만든 핀 조회
+
+operation::member-controller-test/find-pins-by-member[snippets='http-request,http-response']
+
+=== 유저가 만든 토픽 조회
+
+operation::member-controller-test/find-topics-by-member[snippets='http-request,http-response']

backend/src/main/java/com/mapbefine/mapbefine/auth/application/AuthService.java

@@ -23,11 +23,11 @@ public AuthService(MemberRepository memberRepository) {
     }
 
     public boolean isMember(AuthInfo authInfo) {
-        return memberRepository.existsByEmail(authInfo.email());
+        return memberRepository.existsByMemberInfoEmail(authInfo.email());
     }
 
     public AuthMember findAuthMemberByEmail(AuthInfo authInfo) {
-        return memberRepository.findByEmail(authInfo.email())
+        return memberRepository.findByMemberInfoEmail(authInfo.email())
                 .map(this::convertToAuthMember)
                 .orElseGet(Guest::new);
     }
@@ -45,14 +45,14 @@ private AuthMember convertToAuthMember(Member member) {
     }
 
     private List<Long> getTopicsWithPermission(Member member) {
-        return member.getTopicsWithPermission()
+        return member.getTopicsWithPermissions()
                 .stream()
                 .map(Topic::getId)
                 .toList();
     }
 
     private List<Long> getCreatedTopics(Member member) {
-        return member.getCreatedTopic()
+        return member.getCreatedTopics()
                 .stream()
                 .map(Topic::getId)
                 .toList();

backend/src/main/java/com/mapbefine/mapbefine/auth/domain/AuthMember.java

@@ -1,6 +1,5 @@
 package com.mapbefine.mapbefine.auth.domain;
 
-import com.mapbefine.mapbefine.member.domain.Member;
 import com.mapbefine.mapbefine.topic.domain.Topic;
 import java.util.List;
 
@@ -20,20 +19,6 @@ protected AuthMember(
         this.topicsWithPermission = topicsWithPermission;
     }
 
-    private static List<Long> getTopicsWithPermission(Member member) {
-        return member.getTopicsWithPermission()
-                .stream()
-                .map(Topic::getId)
-                .toList();
-    }
-
-    private static List<Long> getCreatedTopics(Member member) {
-        return member.getCreatedTopic()
-                .stream()
-                .map(Topic::getId)
-                .toList();
-    }
-
     public abstract boolean canRead(Topic topic);
 
     public abstract boolean canDelete(Topic topic);

backend/src/main/java/com/mapbefine/mapbefine/member/application/MemberCommandService.java

@@ -1,6 +1,15 @@
 package com.mapbefine.mapbefine.member.application;
 
+import com.mapbefine.mapbefine.auth.domain.AuthMember;
+import com.mapbefine.mapbefine.member.domain.Member;
 import com.mapbefine.mapbefine.member.domain.MemberRepository;
+import com.mapbefine.mapbefine.member.domain.MemberTopicPermission;
+import com.mapbefine.mapbefine.member.domain.MemberTopicPermissionRepository;
+import com.mapbefine.mapbefine.member.dto.request.MemberCreateRequest;
+import com.mapbefine.mapbefine.member.dto.request.MemberTopicPermissionCreateRequest;
+import com.mapbefine.mapbefine.topic.domain.Topic;
+import com.mapbefine.mapbefine.topic.domain.TopicRepository;
+import java.util.NoSuchElementException;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -9,8 +18,101 @@
 public class MemberCommandService {
 
     private final MemberRepository memberRepository;
+    private final TopicRepository topicRepository;
+    private final MemberTopicPermissionRepository memberTopicPermissionRepository;
 
-    public MemberCommandService(MemberRepository memberRepository) {
+    public MemberCommandService(
+            MemberRepository memberRepository,
+            TopicRepository topicRepository,
+            MemberTopicPermissionRepository memberTopicPermissionRepository
+    ) {
         this.memberRepository = memberRepository;
+        this.topicRepository = topicRepository;
+        this.memberTopicPermissionRepository = memberTopicPermissionRepository;
     }
+
+    public Long save(MemberCreateRequest request) {
+        validateUniqueNickName(request.nickName());
+        validateUniqueEmail(request.email());
+
+        Member member = Member.of(
+                request.nickName(),
+                request.email(),
+                request.imageUrl(),
+                request.role()
+        );
+
+        return memberRepository.save(member)
+                .getId();
+    }
+
+    private void validateUniqueNickName(String nickName) {
+        if (memberRepository.existsByMemberInfoNickName(nickName)) {
+            throw new IllegalArgumentException("이미 존재하는 닉네임입니다.");
+        }
+    }
+
+    private void validateUniqueEmail(String email) {
+        if (memberRepository.existsByMemberInfoEmail(email)) {
+            throw new IllegalArgumentException("이미 존재하는 이메일입니다.");
+        }
+    }
+
+    public Long saveMemberTopicPermission(AuthMember authMember, MemberTopicPermissionCreateRequest request) {
+        Member member = memberRepository.findById(request.memberId())
+                .orElseThrow(NoSuchElementException::new);
+        Topic topic = topicRepository.findById(request.topicId())
+                .orElseThrow(NoSuchElementException::new);
+
+        validateSaveMemberTopicPermission(authMember, request, member, topic);
+
+        MemberTopicPermission memberTopicPermission =
+                MemberTopicPermission.createPermissionAssociatedWithTopicAndMember(topic, member);
+
+        return memberTopicPermissionRepository.save(memberTopicPermission).getId();
+    }
+
+    private void validateSaveMemberTopicPermission(
+            AuthMember authMember,
+            MemberTopicPermissionCreateRequest request,
+            Member member,
+            Topic topic
+    ) {
+        validateMemberCanTopicUpdate(authMember, topic);
+        validateSelfPermission(authMember, request);
+        validateDuplicatePermission(topic.getId(), member.getId());
+    }
+
+    private void validateMemberCanTopicUpdate(AuthMember authMember, Topic topic) {
+        if (authMember.canTopicUpdate(topic)) {
+            return;
+        }
+
+        throw new IllegalArgumentException("해당 유저는 해당 토픽에서 다른 유저에게 권한을 줄 수 없습니다.");
+    }
+
+    private void validateSelfPermission(
+            AuthMember authMember,
+            MemberTopicPermissionCreateRequest request
+    ) {
+        if (authMember.getMemberId().equals(request.memberId())) {
+            throw new IllegalArgumentException("본인에게 권한을 줄 수 없습니다.");
+        }
+    }
+
+    private void validateDuplicatePermission(Long topicId, Long memberId) {
+        if (memberTopicPermissionRepository.existsByTopicIdAndMemberId(topicId, memberId)) {
+            throw new IllegalArgumentException("권한은 중복으로 줄 수 없습니다.");
+        }
+    }
+
+    public void deleteMemberTopicPermission(AuthMember authMember, Long permissionId) {
+        MemberTopicPermission memberTopicPermission = memberTopicPermissionRepository.findById(permissionId)
+                .orElseThrow(NoSuchElementException::new);
+
+        validateMemberCanTopicUpdate(authMember, memberTopicPermission.getTopic());
+
+        memberTopicPermissionRepository.delete(memberTopicPermission);
+    }
+
 }

backend/src/main/java/com/mapbefine/mapbefine/member/application/MemberQueryService.java

@@ -1,6 +1,23 @@
 package com.mapbefine.mapbefine.member.application;
 
+import com.mapbefine.mapbefine.auth.domain.AuthMember;
+import com.mapbefine.mapbefine.member.domain.Member;
 import com.mapbefine.mapbefine.member.domain.MemberRepository;
+import com.mapbefine.mapbefine.member.domain.MemberTopicPermission;
+import com.mapbefine.mapbefine.member.domain.MemberTopicPermissionRepository;
+import com.mapbefine.mapbefine.member.dto.response.MemberDetailResponse;
+import com.mapbefine.mapbefine.member.dto.response.MemberResponse;
+import com.mapbefine.mapbefine.member.dto.response.MemberTopicPermissionDetailResponse;
+import com.mapbefine.mapbefine.member.dto.response.MemberTopicPermissionResponse;
+import com.mapbefine.mapbefine.pin.domain.Pin;
+import com.mapbefine.mapbefine.pin.domain.PinRepository;
+import com.mapbefine.mapbefine.pin.dto.response.PinResponse;
+import com.mapbefine.mapbefine.topic.domain.Topic;
+import com.mapbefine.mapbefine.topic.domain.TopicRepository;
+import com.mapbefine.mapbefine.topic.dto.response.TopicResponse;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Objects;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -9,8 +26,75 @@
 public class MemberQueryService {
 
     private final MemberRepository memberRepository;
+    private final TopicRepository topicRepository;
+    private final PinRepository pinRepository;
+    private final MemberTopicPermissionRepository memberTopicPermissionRepository;
 
-    public MemberQueryService(MemberRepository memberRepository) {
+    public MemberQueryService(
+            MemberRepository memberRepository,
+            TopicRepository topicRepository,
+            PinRepository pinRepository,
+            MemberTopicPermissionRepository memberTopicPermissionRepository
+    ) {
         this.memberRepository = memberRepository;
+        this.topicRepository = topicRepository;
+        this.pinRepository = pinRepository;
+        this.memberTopicPermissionRepository = memberTopicPermissionRepository;
     }
+
+    public MemberDetailResponse findById(Long id) {
+        Member member = memberRepository.findById(id)
+                .orElseThrow(NoSuchElementException::new);
+
+        return MemberDetailResponse.from(member);
+    }
+
+    public List<MemberResponse> findAll() {
+        return memberRepository.findAll()
+                .stream()
+                .map(MemberResponse::from)
+                .toList();
+    }
+
+    public List<TopicResponse> findTopicsByMember(AuthMember authMember) {
+        validateNonExistsMember(authMember.getMemberId());
+        List<Topic> topicsByCreator = topicRepository.findByCreatorId(authMember.getMemberId());
+
+        return topicsByCreator.stream()
+                .map(TopicResponse::from)
+                .toList();
+    }
+
+    public List<PinResponse> findPinsByMember(AuthMember authMember) {
+        validateNonExistsMember(authMember.getMemberId());
+        List<Pin> pinsByCreator = pinRepository.findByCreatorId(authMember.getMemberId());
+
+        return pinsByCreator.stream()
+                .map(PinResponse::from)
+                .toList();
+    }
+
+    public void validateNonExistsMember(Long memberId) {
+        if (Objects.isNull(memberId)) {
+            throw new IllegalArgumentException("존재하지 않는 유저입니다.");
+        }
+    }
+
+    public List<MemberTopicPermissionResponse> findAllWithPermission(Long topicId) {
+        Topic topic = topicRepository.findById(topicId)
+                .orElseThrow(NoSuchElementException::new);
+
+        return memberTopicPermissionRepository.findAllByTopic(topic)
+                .stream()
+                .map(MemberTopicPermissionResponse::from)
+                .toList();
+    }
+
+    public MemberTopicPermissionDetailResponse findMemberTopicPermissionById(Long permissionId) {
+        MemberTopicPermission memberTopicPermission = memberTopicPermissionRepository.findById(permissionId)
+                .orElseThrow(NoSuchElementException::new);
+
+        return MemberTopicPermissionDetailResponse.from(memberTopicPermission);
+    }
+
 }