Merge pull request #14 from Nexters/feat/gathering-crud

✨ Feature:  모임 CRUD API 스펙 변경

Author: JunRain2

docker/init.sql

@@ -21,10 +21,7 @@ CREATE TABLE IF NOT EXISTS gathering
     id                   BIGINT AUTO_INCREMENT PRIMARY KEY,
     gathering_name       VARCHAR(255) NOT NULL,
     member_id            BIGINT       NOT NULL,
-    first_gathering_date DATE         NOT NULL,
-    last_gathering_date  DATE         NOT NULL,
     interval_days        BIGINT       NOT NULL,
-    tags                 JSON         NULL,
     created_at           TIMESTAMP    NOT NULL DEFAULT CURRENT_TIMESTAMP,
     updated_at           TIMESTAMP    NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
     deleted_at           TIMESTAMP    NULL,
@@ -64,4 +61,39 @@ CREATE TABLE IF NOT EXISTS invitation
     CONSTRAINT fk_invitation_member_id FOREIGN KEY (member_id) REFERENCES member(id),
     INDEX idx_gathering_member (gathering_id, member_id),
     INDEX idx_deleted_at (deleted_at)
+);
+
+CREATE TABLE IF NOT EXISTS category
+(
+    id         BIGINT AUTO_INCREMENT PRIMARY KEY,
+    name       VARCHAR(255) NOT NULL,
+    created_at TIMESTAMP    NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP    NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP    NULL,
+
+    INDEX idx_deleted_at (deleted_at)
+);
+
+CREATE TABLE IF NOT EXISTS tag
+(
+    id          BIGINT AUTO_INCREMENT PRIMARY KEY,
+    name        VARCHAR(255) NOT NULL,
+    category_id BIGINT       NOT NULL,
+    created_at  TIMESTAMP    NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at  TIMESTAMP    NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    deleted_at  TIMESTAMP    NULL,
+
+    CONSTRAINT fk_tag_category FOREIGN KEY (category_id) REFERENCES category(id),
+    INDEX idx_deleted_at (deleted_at)
+);
+
+CREATE TABLE IF NOT EXISTS gathering_tag
+(
+    id           BIGINT AUTO_INCREMENT PRIMARY KEY,
+    gathering_id BIGINT NOT NULL,
+    tag_id       BIGINT NOT NULL,
+
+    CONSTRAINT fk_gathering_tag_gathering FOREIGN KEY (gathering_id) REFERENCES gathering(id),
+    CONSTRAINT fk_gathering_tag_tag FOREIGN KEY (tag_id) REFERENCES tag(id),
+    UNIQUE KEY uk_gathering_tag (gathering_id, tag_id)
 );

tuk-api/src/main/kotlin/nexters/tuk/application/auth/dto/response/AuthResponse.kt

@@ -1,12 +1,16 @@
 package nexters.tuk.application.auth.dto.response
 
+import io.swagger.v3.oas.annotations.media.Schema
+
 class AuthResponse {
+    @Schema(name = "LoginResponse")
     data class Login(
         val memberId: Long,
         val accessToken: String,
         val refreshToken: String,
     )
 
+    @Schema(name = "RefreshResponse")
     data class Refresh(
         val accessToken: String,
         val refreshToken: String,

tuk-api/src/main/kotlin/nexters/tuk/application/gathering/GatheringAppService.kt

@@ -0,0 +1,36 @@
+package nexters.tuk.application.gathering
+
+import nexters.tuk.application.gathering.dto.request.GatheringCommand
+import nexters.tuk.application.gathering.dto.response.GatheringResponse
+import nexters.tuk.domain.gathering.Gathering
+import nexters.tuk.domain.gathering.GatheringRepository
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Service
+class GatheringGenerateService(
+    private val gatheringRepository: GatheringRepository,
+    private val gatheringMemberService: GatheringMemberService,
+    private val gatheringTagService: GatheringTagService,
+) {
+    @Transactional
+    fun generateGathering(command: GatheringCommand.Generate): GatheringResponse.Generate {
+        val gathering = Gathering.generate(
+            hostId = command.memberId,
+            name = command.gatheringName,
+            intervalDays = command.gatheringIntervalDays
+        ).also { gatheringRepository.save(it) }
+
+        val gatheringTags = gatheringTagService.addTags(gathering.id, command.tags)
+
+        gatheringMemberService.joinGathering(
+            gatheringId = gathering.id,
+            memberId = command.memberId,
+        )
+
+        // TODO 알림 등록하기
+        return GatheringResponse.Generate(
+            gathering.id,
+        )
+    }
+}

tuk-api/src/main/kotlin/nexters/tuk/application/gathering/GatheringGenerateService.kt

@@ -1,21 +1,19 @@
 package nexters.tuk.application.gathering
 
-import nexters.tuk.application.gathering.dto.response.GatheringResponse
+import nexters.tuk.application.gathering.dto.response.GatheringMemberResponse
 import nexters.tuk.contract.BaseException
 import nexters.tuk.contract.ErrorType
 import nexters.tuk.domain.gathering.*
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
-import java.time.LocalDate
-import java.time.temporal.ChronoUnit
 
 @Service
 class GatheringMemberService(
     private val gatheringRepository: GatheringRepository,
     private val gatheringMemberRepository: GatheringMemberRepository
 ) {
     @Transactional
-    fun registerMember(gatheringId: Long, memberId: Long): Long {
+    fun joinGathering(gatheringId: Long, memberId: Long): GatheringMemberResponse.JoinGathering {
         val gathering = gatheringRepository.findByIdOrThrow(gatheringId)
         if (gathering.hasMember(memberId)) {
             throw BaseException(ErrorType.BAD_REQUEST, "이미 가입된 사용자입니다.")
@@ -24,32 +22,27 @@ class GatheringMemberService(
         val gatheringMember = GatheringMember.registerMember(gathering, memberId)
             .also { gatheringMemberRepository.save(it) }
 
-        return gatheringMember.id
+        return GatheringMemberResponse.JoinGathering(gatheringMember.id)
     }
 
     private fun Gathering.hasMember(memberId: Long): Boolean {
         return gatheringMemberRepository.findByGatheringAndMemberId(this, memberId) != null
     }
 
     @Transactional(readOnly = true)
-    fun getMemberGatherings(memberId: Long): List<GatheringResponse.GatheringOverview> {
+    fun getMemberGatherings(memberId: Long): List<GatheringMemberResponse.MemberGatherings> {
         val gatheringMembers = gatheringMemberRepository.findAllByMemberId(memberId)
 
         return gatheringMembers
             .map { it.gathering }
             .map {
-                GatheringResponse.GatheringOverview(
+                GatheringMemberResponse.MemberGatherings(
                     it.id,
                     it.name,
-                    it.lastGatheringDate.monthsAgo()
                 )
             }.sortedBy { it.name }
     }
 
-    private fun LocalDate.monthsAgo(): Int {
-        return until(LocalDate.now(), ChronoUnit.MONTHS).toInt()
-    }
-
     @Transactional(readOnly = true)
     fun verifyGatheringAccess(gatheringId: Long, memberId: Long) {
         val gathering = gatheringRepository.findByIdOrThrow(gatheringId)

tuk-api/src/main/kotlin/nexters/tuk/application/gathering/GatheringMemberService.kt

@@ -0,0 +1,56 @@
+package nexters.tuk.application.gathering
+
+import nexters.tuk.application.gathering.dto.request.GatheringQuery
+import nexters.tuk.application.gathering.dto.response.GatheringResponse
+import nexters.tuk.application.invitation.InvitationService
+import nexters.tuk.application.member.MemberService
+import nexters.tuk.domain.gathering.GatheringRepository
+import nexters.tuk.domain.gathering.findByIdOrThrow
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Service
+// TODO 알림 추가시 마지막 알림 날짜를 가져오는 로직 구현, 현재는 0으로 설정
+class GatheringQueryService(
+    private val gatheringRepository: GatheringRepository,
+    private val gatheringMemberService: GatheringMemberService,
+    private val invitationService: InvitationService,
+    private val memberService: MemberService,
+) {
+    @Transactional(readOnly = true)
+    fun getMemberGatherings(query: GatheringQuery.MemberGathering): GatheringResponse.GatheringOverviews {
+        val gatheringOverviews = gatheringMemberService.getMemberGatherings(query.memberId)
+            .map {
+            GatheringResponse.GatheringOverviews.GatheringOverview(
+                gatheringId = it.id,
+                gatheringName = it.name,
+                monthsSinceLastGathering = 0
+            )
+        }
+
+        return GatheringResponse.GatheringOverviews(gatheringOverviews.size, gatheringOverviews)
+    }
+
+    @Transactional(readOnly = true)
+    fun getGatheringDetail(query: GatheringQuery.GatheringDetail): GatheringResponse.GatheringDetail {
+        gatheringMemberService.verifyGatheringAccess(query.gatheringId, query.memberId)
+
+        val invitationStat = invitationService.getGatheringInvitationStat(query.gatheringId, query.memberId)
+
+        val gatheringMemberIds = gatheringMemberService.getGatheringMemberIds(query.gatheringId)
+        val members = memberService.getMemberOverview(gatheringMemberIds).map {
+            GatheringResponse.GatheringDetail.MemberOverview(it.memberId, it.memberName)
+        }
+
+        val gatheringDetail = gatheringRepository.findByIdOrThrow(query.gatheringId)
+
+        return GatheringResponse.GatheringDetail(
+            gatheringId = gatheringDetail.id,
+            gatheringName = gatheringDetail.name,
+            monthsSinceLastNotification = 0,
+            sentInvitationCount = invitationStat.sentCount,
+            receivedInvitationCount = invitationStat.receivedCount,
+            members = members
+        )
+    }
+}

tuk-api/src/main/kotlin/nexters/tuk/application/gathering/GatheringQueryService.kt

@@ -0,0 +1,25 @@
+package nexters.tuk.application.gathering
+
+import nexters.tuk.application.gathering.dto.response.GatheringTagResponse
+import nexters.tuk.domain.gathering.GatheringRepository
+import nexters.tuk.domain.gathering.GatheringTag
+import nexters.tuk.domain.gathering.GatheringTagRepository
+import nexters.tuk.domain.gathering.findByIdOrThrow
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Service
+class GatheringTagService(
+    private val gatheringRepository: GatheringRepository,
+    private val gatheringTagRepository: GatheringTagRepository
+) {
+    @Transactional
+    fun addTags(gatheringId: Long, tagsId: List<Long>): GatheringTagResponse.AddTag {
+        val gathering = gatheringRepository.findByIdOrThrow(gatheringId)
+
+        val gatheringTags = tagsId.map { GatheringTag.addTag(gathering, it) }
+            .also { gatheringTagRepository.saveAll(it) }
+
+        return GatheringTagResponse.AddTag(gatheringTags.map { it.id })
+    }
+}

tuk-api/src/main/kotlin/nexters/tuk/application/gathering/GatheringService.kt

@@ -5,9 +5,8 @@ class GatheringCommand {
     data class Generate(
         val memberId: Long,
         val gatheringName: String,
-        val daysSinceLastGathering: Long,
         val gatheringIntervalDays: Long,
-        val tags: List<String>,
+        val tags: List<Long>,
     )
 
     data class JoinGathering(