fix: 글쓰기 화면에서 내 강의/미션 목록 보이게 하기

woowacourse · Jan 20, 2025 · 3e73605 · 3e73605
1 parent a03b2e0
commit 3e73605
Show file tree

Hide file tree

Showing 7 changed files with 49 additions and 102 deletions.
diff --git a/backend/src/main/java/wooteco/prolog/organization/application/OrganizationService.java b/backend/src/main/java/wooteco/prolog/organization/application/OrganizationService.java
@@ -4,6 +4,7 @@
 import java.util.stream.Collectors;
 import org.springframework.context.event.EventListener;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 import wooteco.prolog.member.domain.MemberCreatedEvent;
 import wooteco.prolog.organization.domain.Organization;
 import wooteco.prolog.organization.domain.OrganizationGroup;
@@ -16,6 +17,7 @@
 import wooteco.prolog.session.domain.Session;
 
 @Service
+@Transactional(readOnly = true)
 public class OrganizationService {
 
     private final OrganizationRepository organizationRepository;
@@ -33,14 +35,17 @@ public OrganizationService(OrganizationRepository organizationRepository,
         this.organizationGroupSessionRepository = organizationGroupSessionRepository;
     }
 
+    @Transactional
     public Organization saveOrganization(String name) {
         return organizationRepository.save(new Organization(name));
     }
 
+    @Transactional
     public OrganizationGroup saveOrganizationGroup(Long organizationId, String name) {
         return organizationGroupRepository.save(new OrganizationGroup(organizationId, name));
     }
 
+    @Transactional
     public void addOrganizationGroupMember(Long organizationGroupId,
                                            List<OrganizationGroupMemberRequest> organizationGroupMemberRequests) {
         List<OrganizationGroupMember> organizationGroupMembers = organizationGroupMemberRequests.stream()
@@ -50,6 +55,7 @@ public void addOrganizationGroupMember(Long organizationGroupId,
         organizationGroupMemberRepository.saveAll(organizationGroupMembers);
     }
 
+    @Transactional
     public void addOrganizationGroupSessions(Long organizationGroupId, List<String> sessionNames) {
         List<OrganizationGroupSession> organizationGroupSessions = sessionNames.stream()
             .map(it -> new OrganizationGroupSession(organizationGroupId, new Session(it)))

diff --git a/backend/src/main/java/wooteco/prolog/session/application/MissionService.java b/backend/src/main/java/wooteco/prolog/session/application/MissionService.java
@@ -63,7 +63,7 @@ public List<Mission> findByIds(List<Long> missionIds) {
     }
 
     public List<MissionResponse> findMyMissions(LoginMember loginMember) {
-        List<Long> mySessionIds = sessionService.findMySessionIds(loginMember.getId());
+        List<Long> mySessionIds = sessionService.findMySessionIds(loginMember);
         List<Mission> missions = missionRepository.findBySessionIdIn(mySessionIds);
         return MissionResponse.listOf(missions);
     }

diff --git a/backend/src/main/java/wooteco/prolog/session/application/SessionService.java b/backend/src/main/java/wooteco/prolog/session/application/SessionService.java
@@ -8,12 +8,15 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import lombok.AllArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import wooteco.prolog.common.exception.BadRequestException;
 import wooteco.prolog.login.ui.LoginMember;
+import wooteco.prolog.organization.application.OrganizationService;
+import wooteco.prolog.organization.domain.OrganizationGroupSession;
 import wooteco.prolog.session.application.dto.SessionRequest;
 import wooteco.prolog.session.application.dto.SessionResponse;
 import wooteco.prolog.session.domain.Session;
@@ -25,8 +28,9 @@
 @Transactional(readOnly = true)
 public class SessionService {
 
-    private SessionMemberService sessionMemberService;
-    private SessionRepository sessionRepository;
+    private final SessionMemberService sessionMemberService;
+    private final OrganizationService organizationService;
+    private final SessionRepository sessionRepository;
 
     @Transactional
     public SessionResponse create(SessionRequest sessionRequest) {
@@ -67,46 +71,40 @@ public List<SessionResponse> findAllOrderByDesc() {
             .collect(toList());
     }
 
-    public List<SessionResponse> findAllByOrderByIdDesc() {
-        return sessionRepository.findAllByOrderByIdDesc().stream()
-            .map(SessionResponse::of)
-            .collect(toList());
-    }
+    public List<SessionResponse> findMySessions(LoginMember loginMember) {
+        List<SessionResponse> mySessionResponses = findMySessionOnlyMine(loginMember);
+        List<OrganizationGroupSession> organizationGroupSessions = organizationService.findOrganizationGroupSessionsByMemberId(
+            loginMember.getId());
+        List<SessionResponse> organizationSessions = organizationGroupSessions.stream()
+            .map(it -> SessionResponse.of(it.getSession()))
+            .collect(Collectors.toList());
+        mySessionResponses.removeAll(organizationSessions);
 
-    public List<SessionResponse> findMySessions(LoginMember member) {
-        List<Long> sessionIds = findMySessionIds(member.getId());
-
-        return sessionRepository.findAllByIdInOrderByIdDesc(sessionIds).stream()
-            .map(SessionResponse::of)
+        return Stream.of(mySessionResponses, organizationSessions)
+            .flatMap(Collection::stream)
+            .sorted((s1, s2) -> Long.compare(s2.getId(), s1.getId()))
             .collect(toList());
     }
 
-    public List<Long> findMySessionIds(Long memberId) {
-        return sessionMemberService.findByMemberId(memberId)
-            .stream()
-            .map(SessionMember::getSessionId)
-            .collect(toList());
+    public List<Long> findMySessionIds(LoginMember loginMember) {
+        return findMySessions(loginMember).stream().map(SessionResponse::getId).collect(toList());
     }
 
-    public List<SessionResponse> findAllWithMySessionFirst(LoginMember loginMember) {
+    public List<SessionResponse> findMySessionOnlyMine(LoginMember loginMember) {
         if (loginMember.isAnonymous()) {
-            return findAllByOrderByIdDesc();
+            return new ArrayList<>();
         }
+        List<Long> mySessionIds = findMySessionIds(loginMember.getId());
 
-        List<SessionResponse> mySessions = findMySessions(loginMember);
-        List<SessionResponse> allSessions = findAllByOrderByIdDesc();
-        allSessions.removeAll(mySessions);
-
-        return Stream.of(mySessions, allSessions)
-            .flatMap(Collection::stream)
+        return sessionRepository.findAllByIdInOrderByIdDesc(mySessionIds).stream()
+            .map(SessionResponse::of)
             .collect(toList());
     }
 
-    public List<SessionResponse> findMySessionResponses(LoginMember loginMember) {
-        if (loginMember.isAnonymous()) {
-            return new ArrayList<>();
-        }
-
-        return findMySessions(loginMember);
+    private List<Long> findMySessionIds(Long memberId) {
+        return sessionMemberService.findByMemberId(memberId)
+            .stream()
+            .map(SessionMember::getSessionId)
+            .collect(toList());
     }
 }
diff --git a/backend/src/main/java/wooteco/prolog/studylog/application/FilterService.java b/backend/src/main/java/wooteco/prolog/studylog/application/FilterService.java
@@ -1,16 +1,9 @@
 package wooteco.prolog.studylog.application;
 
-import static java.util.stream.Collectors.toList;
-
-import java.util.Collection;
 import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 import lombok.AllArgsConstructor;
 import org.springframework.stereotype.Service;
 import wooteco.prolog.login.ui.LoginMember;
-import wooteco.prolog.organization.application.OrganizationService;
-import wooteco.prolog.organization.domain.OrganizationGroupSession;
 import wooteco.prolog.session.application.MissionService;
 import wooteco.prolog.session.application.SessionService;
 import wooteco.prolog.session.application.dto.MissionResponse;
@@ -23,25 +16,14 @@ public class FilterService {
 
     private final SessionService sessionService;
     private final MissionService missionService;
-    private final OrganizationService organizationService;
 
     public FilterResponse showAll(LoginMember loginMember) {
         List<SessionResponse> sessionResponses = sessionService.findAllOrderByDesc();
         List<MissionResponse> missionResponses = missionService.findAllWithMyMissionFirst(loginMember);
 
-        List<SessionResponse> mySessionResponses = sessionService.findMySessionResponses(loginMember);
-        List<OrganizationGroupSession> organizationGroupSessions = organizationService.findOrganizationGroupSessionsByMemberId(
-            loginMember.getId());
-        List<SessionResponse> organizationSessions = organizationGroupSessions.stream()
-            .map(it -> SessionResponse.of(it.getSession()))
-            .collect(Collectors.toList());
-        mySessionResponses.removeAll(organizationSessions);
-
-        List<SessionResponse> mySessions = Stream.of(mySessionResponses, organizationSessions)
-            .flatMap(Collection::stream)
-            .sorted((s1, s2) -> Long.compare(s2.getId(), s1.getId()))
-            .collect(toList());
+        List<SessionResponse> mySessions = sessionService.findMySessions(loginMember);
 
         return new FilterResponse(sessionResponses, mySessions, missionResponses);
     }
+
 }
diff --git a/backend/src/test/java/wooteco/prolog/session/application/MissionServiceTest.java b/backend/src/test/java/wooteco/prolog/session/application/MissionServiceTest.java
@@ -183,7 +183,7 @@ void findMyMissions() {
         final List<Mission> missions = new ArrayList<>();
         missions.add(new Mission("mission1", new Session("session1")));
 
-        when(sessionService.findMySessionIds(loginMember.getId())).thenReturn(mySessionIds);
+        when(sessionService.findMySessionIds(loginMember)).thenReturn(mySessionIds);
         when(missionRepository.findBySessionIdIn(mySessionIds)).thenReturn(missions);
 
         // when

diff --git a/backend/src/test/java/wooteco/prolog/session/application/SessionServiceTest.java b/backend/src/test/java/wooteco/prolog/session/application/SessionServiceTest.java
@@ -3,13 +3,13 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doReturn;
 import static wooteco.prolog.common.exception.BadRequestCode.DUPLICATE_SESSION_EXCEPTION;
 import static wooteco.prolog.common.exception.BadRequestCode.ROADMAP_SESSION_NOT_FOUND_EXCEPTION;
 import static wooteco.prolog.login.ui.LoginMember.Authority.MEMBER;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
 import org.junit.jupiter.api.DisplayName;
@@ -22,6 +22,7 @@
 import wooteco.prolog.login.ui.LoginMember;
 import wooteco.prolog.member.domain.Member;
 import wooteco.prolog.member.domain.Role;
+import wooteco.prolog.organization.application.OrganizationService;
 import wooteco.prolog.session.application.dto.SessionRequest;
 import wooteco.prolog.session.application.dto.SessionResponse;
 import wooteco.prolog.session.domain.Session;
@@ -34,11 +35,12 @@ class SessionServiceTest {
     @InjectMocks
     private SessionService sessionService;
 
+    @Mock
+    private SessionRepository sessionRepository;
     @Mock
     private SessionMemberService sessionMemberService;
-
     @Mock
-    private SessionRepository sessionRepository;
+    private OrganizationService organizationService;
 
     @DisplayName("유효한 이름 값을 매개변수로 넣으면 Session 객체가 정상적으로 생성된다.")
     @Test
@@ -128,63 +130,22 @@ void findAll() {
         );
     }
 
-    @DisplayName("현재 로그인한 Memeber의 Session을 조회한다.")
-    @Test
-    void findMySessions() {
-        // given
-        final LoginMember member = new LoginMember(1L, MEMBER);
-        final List<Session> sessions = new ArrayList<>();
-        sessions.add(new Session("session1"));
-
-        final List<SessionMember> sessionMembers = new ArrayList<>();
-        sessionMembers.add(new SessionMember(1L, new Member("member1", "베베", Role.CREW, Long.MIN_VALUE, "img")));
-
-        doReturn(sessionMembers).when(sessionMemberService).findByMemberId(member.getId());
-        doReturn(sessions).when(sessionRepository).findAllByIdInOrderByIdDesc(Arrays.asList(1L));
-
-        // when
-        List<SessionResponse> responses = sessionService.findMySessions(member);
-
-        // then
-        assertThat(responses.get(0).getName()).isEqualTo("session1");
-    }
-
-    @DisplayName("현재 로그인한 Member의 SessionId들을 조회한다.")
-    @Test
-    void findMySessionIds() {
-        // given
-        final LoginMember member = new LoginMember(1L, MEMBER);
-        final List<SessionMember> sessionMembers = new ArrayList<>();
-        sessionMembers.add(new SessionMember(1L, new Member("member1", "베베", Role.CREW, Long.MIN_VALUE, "img")));
-
-        doReturn(sessionMembers).when(sessionMemberService).findByMemberId(member.getId());
-
-        // when
-        List<Long> sessionIds = sessionService.findMySessionIds(member.getId());
-
-        // then
-        assertAll(
-            () -> assertThat(sessionIds.get(0)).isEqualTo(1L),
-            () -> assertThat(sessionIds.size()).isEqualTo(1)
-        );
-    }
-
     @DisplayName("현재 로그인한 Member의 Session을 조회한다.")
     @Test
     void findMySessionResponses() {
         // given
         final LoginMember member = new LoginMember(1L, MEMBER);
         final List<Session> sessions = new ArrayList<>();
         sessions.add(new Session("session1"));
-
         final List<SessionMember> sessionMembers = new ArrayList<>();
         sessionMembers.add(new SessionMember(1L, new Member("member1", "베베", Role.CREW, Long.MIN_VALUE, "img")));
 
-        doReturn(sessionMembers).when(sessionMemberService).findByMemberId(member.getId());
-        doReturn(sessions).when(sessionRepository).findAllByIdInOrderByIdDesc(Arrays.asList(1L));
+        doReturn(List.of()).when(organizationService).findOrganizationGroupSessionsByMemberId(any());
+        doReturn(sessionMembers).when(sessionMemberService).findByMemberId(any());
+        doReturn(sessions).when(sessionRepository).findAllByIdInOrderByIdDesc(any());
 
         // when
-        List<SessionResponse> responses = sessionService.findMySessionResponses(member);
+        List<SessionResponse> responses = sessionService.findMySessions(member);
 
         // then
         assertThat(responses.get(0).getName()).isEqualTo("session1");

diff --git a/backend/src/test/java/wooteco/prolog/studylog/application/FilterServiceTest.java b/backend/src/test/java/wooteco/prolog/studylog/application/FilterServiceTest.java
@@ -54,7 +54,7 @@ void showAll() {
 
         SessionResponse session2 = new SessionResponse(2L, "session2");
         List<SessionResponse> mySessionResponses = Collections.newArrayList(session2);
-        doReturn(mySessionResponses).when(sessionService).findMySessionResponses(loginMember);
+        doReturn(mySessionResponses).when(sessionService).findMySessionOnlyMine(loginMember);
 
         Session session3 = new Session(3L, null, "session3");
         List<OrganizationGroupSession> organizationGroupSessions = Collections.newArrayList(