refactor: 스터디 엔티티 수정

backend/src/main/java/com/yigongil/backend/domain/round/Round.java

@@ -60,6 +60,8 @@ public class Round extends BaseEntity {
     @JoinColumn(name = "round_id", nullable = false)
     private List<RoundOfMember> roundOfMembers = new ArrayList<>();
 
+    private Integer weekNumber;
+
     protected Round() {
     }
 

backend/src/main/java/com/yigongil/backend/domain/study/ProgressDayOfWeek.java

@@ -0,0 +1,22 @@
+package com.yigongil.backend.domain.study;
+
+import javax.persistence.EmbeddedId;
+import javax.persistence.Entity;
+import javax.persistence.JoinColumn;
+import javax.persistence.ManyToOne;
+import javax.persistence.MapsId;
+
+@Entity
+public class ProgressDayOfWeek {
+
+    @EmbeddedId
+    private ProgressDayOfWeekKey id;
+
+    @ManyToOne
+    @MapsId("studyId")
+    @JoinColumn(name = "study_id")
+    private Study study;
+
+}
+
+

backend/src/main/java/com/yigongil/backend/domain/study/ProgressDayOfWeekKey.java

@@ -0,0 +1,18 @@
+package com.yigongil.backend.domain.study;
+
+import java.io.Serializable;
+import javax.persistence.Column;
+import javax.persistence.Embeddable;
+import lombok.Getter;
+
+@Getter
+@Embeddable
+public class ProgressDayOfWeekKey implements Serializable {
+
+    @Column(name = "study_id")
+    private Long studyId;
+
+    @Column(name = "progress_day_of_week")
+    private int progressDayOfWeek;
+
+}

backend/src/main/java/com/yigongil/backend/domain/study/Study.java

@@ -4,16 +4,13 @@
 import com.yigongil.backend.domain.member.Member;
 import com.yigongil.backend.domain.round.Round;
 import com.yigongil.backend.domain.roundofmember.RoundOfMember;
-import com.yigongil.backend.exception.CannotStartException;
 import com.yigongil.backend.exception.InvalidMemberSizeException;
 import com.yigongil.backend.exception.InvalidNumberOfMaximumStudyMember;
 import com.yigongil.backend.exception.InvalidProcessingStatusException;
 import com.yigongil.backend.exception.InvalidStudyNameLengthException;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
-import java.time.LocalTime;
 import java.util.ArrayList;
-import java.util.Comparator;
 import java.util.List;
 import java.util.Optional;
 import javax.persistence.Column;
@@ -59,20 +56,12 @@ public class Study extends BaseEntity {
     @Enumerated(value = EnumType.STRING)
     private ProcessingStatus processingStatus;
 
-    @Column(nullable = false)
     private LocalDateTime startAt;
 
     private LocalDateTime endAt;
 
     @Column(nullable = false)
-    private Integer totalRoundCount;
-
-    @Column(nullable = false)
-    private Integer periodOfRound;
-
-    @Column(nullable = false)
-    @Enumerated(value = EnumType.STRING)
-    private PeriodUnit periodUnit;
+    private int minimumWeeks;
 
     @Column(nullable = false)
     private Integer currentRoundNumber;
@@ -95,11 +84,8 @@ public Study(
             ProcessingStatus processingStatus,
             LocalDateTime startAt,
             LocalDateTime endAt,
-            Integer totalRoundCount,
-            Integer periodOfRound,
             Integer currentRoundNumber,
-            List<Round> rounds,
-            PeriodUnit periodUnit
+            List<Round> rounds
     ) {
         name = name.strip();
         validateNumberOfMaximumMembers(numberOfMaximumMembers);
@@ -111,13 +97,33 @@ public Study(
         this.processingStatus = processingStatus;
         this.startAt = startAt;
         this.endAt = endAt;
-        this.totalRoundCount = totalRoundCount;
-        this.periodOfRound = periodOfRound;
-        this.periodUnit = periodUnit;
         this.currentRoundNumber = currentRoundNumber == null ? 1 : currentRoundNumber;
         this.rounds = rounds == null ? new ArrayList<>() : rounds;
     }
 
+    public static Study initializeStudyOf(
+        String name,
+        String introduction,
+        Integer numberOfMaximumMembers,
+        LocalDateTime startAt,
+        Integer totalRoundCount,
+        String periodOfRound,
+        Member master
+    ) {
+        Study study = Study.builder()
+                             .name(name)
+                             .numberOfMaximumMembers(numberOfMaximumMembers)
+                             .startAt(startAt)
+                             .totalRoundCount(totalRoundCount)
+                             .periodOfRound(PeriodUnit.getPeriodNumber(periodOfRound))
+                             .periodUnit(PeriodUnit.getPeriodUnit(periodOfRound))
+                             .introduction(introduction)
+                             .processingStatus(ProcessingStatus.RECRUITING)
+                             .build();
+        study.rounds = Round.of(totalRoundCount, master);
+        return study;
+    }
+
     private void validateNumberOfMaximumMembers(Integer numberOfMaximumMembers) {
         if (numberOfMaximumMembers < MIN_MEMBER_SIZE || numberOfMaximumMembers > MAX_MEMBER_SIZE) {
             throw new InvalidNumberOfMaximumStudyMember(
@@ -143,29 +149,6 @@ private void validateName(String name) {
         }
     }
 
-    public static Study initializeStudyOf(
-            String name,
-            String introduction,
-            Integer numberOfMaximumMembers,
-            LocalDateTime startAt,
-            Integer totalRoundCount,
-            String periodOfRound,
-            Member master
-    ) {
-        Study study = Study.builder()
-                           .name(name)
-                           .numberOfMaximumMembers(numberOfMaximumMembers)
-                           .startAt(startAt)
-                           .totalRoundCount(totalRoundCount)
-                           .periodOfRound(PeriodUnit.getPeriodNumber(periodOfRound))
-                           .periodUnit(PeriodUnit.getPeriodUnit(periodOfRound))
-                           .introduction(introduction)
-                           .processingStatus(ProcessingStatus.RECRUITING)
-                           .build();
-        study.rounds = Round.of(totalRoundCount, master);
-        return study;
-    }
-
     public Integer calculateAverageTier() {
         return getCurrentRound().calculateAverageTier();
     }
@@ -214,60 +197,11 @@ private void finishStudy() {
         this.processingStatus = ProcessingStatus.END;
     }
 
-    public void startStudy() {
-        if (processingStatus != ProcessingStatus.RECRUITING) {
-            throw new CannotStartException("시작할 수 없는 상태입니다.", id);
-        }
-        if (sizeOfCurrentMembers() == ONE_MEMBER) {
-            throw new CannotStartException("시작할 수 없는 상태입니다.", id);
-        }
-        this.startAt = LocalDateTime.now();
-        this.processingStatus = ProcessingStatus.PROCESSING;
-        initializeRoundsEndAt();
-    }
-
-    private void initializeRoundsEndAt() {
-        rounds.sort(Comparator.comparing(Round::getRoundNumber));
-        LocalDateTime date = LocalDateTime.of(startAt.toLocalDate(), LocalTime.MIN);
-        for (Round round : rounds) {
-            date = date.plusDays(calculateStudyPeriod());
-            round.updateEndAt(date);
-        }
-    }
-
-    public int calculateStudyPeriod() {
-        return periodOfRound * periodUnit.getUnitNumber();
-    }
-
-    public String findPeriodOfRoundToString() {
-        return periodUnit.toStringFormat(periodOfRound);
-    }
-
     public Member getMaster() {
         return getCurrentRound().getMaster();
     }
 
-    public void updateInformation(
-            Member member,
-            String name,
-            Integer numberOfMaximumMembers,
-            LocalDateTime startAt,
-            Integer totalRoundCount,
-            String periodOfRound,
-            String introduction
-    ) {
-        validateMaster(member);
-        validateStudyProcessingStatus();
-        this.name = name;
-        this.numberOfMaximumMembers = numberOfMaximumMembers;
-        this.startAt = startAt;
-        this.totalRoundCount = totalRoundCount;
-        this.periodOfRound = PeriodUnit.getPeriodNumber(periodOfRound);
-        this.periodUnit = PeriodUnit.getPeriodUnit(periodOfRound);
-        this.introduction = introduction;
-    }
-
-    private void validateStudyProcessingStatus() {
+    protected void validateStudyProcessingStatus() {
         if (!isRecruiting()) {
             throw new InvalidProcessingStatusException("현재 스터디의 상태가 모집중이 아닙니다.",
                     processingStatus.name());
@@ -306,4 +240,15 @@ public Round getCurrentRound() {
     public boolean isMaster(Member member) {
         return getCurrentRound().isMaster(member);
     }
+
+    protected void updateInformation(Member member, String name, Integer numberOfMaximumMembers, LocalDateTime startAt, String introduction) {
+        validateName(name);
+        validateNumberOfMaximumMembers(numberOfMaximumMembers);
+        validateMaster(member);
+        validateStudyProcessingStatus();
+        this.name = name;
+        this.numberOfMaximumMembers = numberOfMaximumMembers;
+        this.startAt = startAt;
+        this.introduction = introduction;
+    }
 }

backend/src/main/resources/db/migration/V11__seperate_study_table.sql

@@ -0,0 +1,19 @@
+ALTER TABLE round
+    ADD COLUMN week_number integer;
+ALTER TABLE study
+    ADD COLUMN minimum_weeks integer NOT NULL;
+
+create table progress_day_of_week
+(
+    study_id             bigint  not null,
+    progress_day_of_week integer not null,
+    primary key (study_id, progress_day_of_week)
+);
+
+ALTER TABLE progress_day_of_week
+    ADD CONSTRAINT FKbto00gu5esijcq0wtn13fd7pd
+        FOREIGN KEY (study_id) REFERENCES study(id);
+
+ALTER TABLE study DROP COLUMN period_of_round;
+ALTER TABLE study DROP COLUMN period_unit;
+ALTER TABLE study DROP COLUMN total_round_count;

backend/src/test/java/com/yigongil/backend/domain/study/StudyTest.java

@@ -20,17 +20,6 @@
 
 class StudyTest {
 
-    @Test
-    void 스터디_주기를_계산한다() {
-        Study study1 = StudyFixture.자바_스터디_모집중.toStudy();
-        Study study2 = StudyFixture.자바_스터디_진행중.toStudy();
-
-        assertAll(
-                () -> assertThat(study1.calculateStudyPeriod()).isEqualTo(21),
-                () -> assertThat(study2.calculateStudyPeriod()).isEqualTo(3)
-        );
-    }
-
     @Test
     void 스터디를_다음_라운드로_넘기면_현재_라운드가_다음_라운드로_변한다() {
         // given