#134 - 바뀐 인텔리에 따라 스펙을 수정합니다.

app/src/main/kotlin/com/wespot/message/v2/MessageV2UsingStatusController.kt

@@ -0,0 +1,23 @@
+package com.wespot.message.v2
+
+import com.wespot.message.dto.response.MessageV2StatusResponse
+import com.wespot.message.port.`in`.MessageV2UsingStatusUseCase
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping("/api/v2/messages")
+class MessageV2UsingStatusController(
+    private val messageV2UsingStatusUseCase: MessageV2UsingStatusUseCase,
+) {
+
+    @GetMapping("/status")
+    fun getMessageStatus(): ResponseEntity<MessageV2StatusResponse> {
+        val response = messageV2UsingStatusUseCase.getMessageStatus()
+
+        return ResponseEntity.ok(response)
+    }
+
+}

core/src/main/kotlin/com/wespot/message/dto/response/MessageV2StatusResponse.kt

@@ -0,0 +1,30 @@
+package com.wespot.message.dto.response
+
+import com.wespot.message.v2.MessageV2
+
+data class MessageV2StatusResponse(
+    val isSendAllowed: Boolean,
+    val countRemainingMessages: Int,
+    val countUnReadMessages: Int,
+    val countUnReplayMessages: Int,
+) {
+
+    companion object {
+
+        fun of(
+            isSendAllowed: Boolean,
+            countRemainingMessages: Int,
+            countUnReadMessages: Int,
+            countUnReplayMessages: Int,
+        ): MessageV2StatusResponse {
+            return MessageV2StatusResponse(
+                isSendAllowed = isSendAllowed,
+                countRemainingMessages = countRemainingMessages,
+                countUnReadMessages = countUnReadMessages,
+                countUnReplayMessages = countUnReplayMessages,
+            )
+        }
+
+    }
+
+}

core/src/main/kotlin/com/wespot/message/port/in/MessageV2UsingStatusUseCase.kt

@@ -0,0 +1,9 @@
+package com.wespot.message.port.`in`
+
+import com.wespot.message.dto.response.MessageV2StatusResponse
+
+interface MessageV2UsingStatusUseCase {
+
+    fun getMessageStatus(): MessageV2StatusResponse
+
+}

core/src/main/kotlin/com/wespot/message/port/out/MessageV2Port.kt

@@ -1,12 +1,13 @@
 package com.wespot.message.port.out
 
 import com.wespot.message.v2.MessageV2
+import java.time.LocalDate
 
 interface MessageV2Port {
 
     fun save(messageV2: MessageV2): MessageV2
 
-    fun countTodaySendMessages(userId: Long): Int
+    fun countTodaySendMessages(senderId: Long): Int
 
     fun findAllMessageRoomBySenderId(senderId: Long): List<MessageV2>
 
@@ -24,4 +25,6 @@ interface MessageV2Port {
 
     fun findAllMessageRoomBySenderIdAndReceiverId(senderId: Long, receiverId: Long): List<MessageV2>
 
+    fun findAllLastMessageOfRoomByReceiverIdAndFromDate(receiverId: Long, from: LocalDate): List<MessageV2>
+
 }

core/src/main/kotlin/com/wespot/message/service/v2/MessageV2UsingStatusService.kt

@@ -0,0 +1,39 @@
+package com.wespot.message.service.v2
+
+import com.wespot.auth.service.SecurityUtils
+import com.wespot.message.dto.response.MessageV2StatusResponse
+import com.wespot.message.port.`in`.MessageV2UsingStatusUseCase
+import com.wespot.message.port.out.MessageV2Port
+import com.wespot.message.v2.MessageV2
+import com.wespot.user.port.out.UserPort
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import java.time.LocalDate
+
+@Service
+class MessageV2UsingStatusService(
+    private val userPort: UserPort,
+    private val messageV2Port: MessageV2Port,
+) : MessageV2UsingStatusUseCase {
+
+    @Transactional(readOnly = true)
+    override fun getMessageStatus(): MessageV2StatusResponse {
+        val loginUser = SecurityUtils.getLoginUser(userPort = userPort)
+        val today = LocalDate.now()
+        val yesterday = today.minusDays(1)
+        val messages =
+            messageV2Port.findAllLastMessageOfRoomByReceiverIdAndFromDate(
+                receiverId = loginUser.id,
+                from = yesterday
+            )
+        val countTodaySentMessage = messageV2Port.countTodaySendMessages(senderId = loginUser.id)
+
+        return MessageV2StatusResponse.of(
+            isSendAllowed = MessageV2.COUNT_OF_MAX_ABLE_TO_SEND_MESSAGE_PER_DAY == countTodaySentMessage,
+            countRemainingMessages = MessageV2.COUNT_OF_MAX_ABLE_TO_SEND_MESSAGE_PER_DAY - countTodaySentMessage,
+            countUnReadMessages = messages.filter { !it.isRead(viewer = loginUser) }.size,
+            countUnReplayMessages = messages.filter { it.isSentAtSameDate(date = today) }.size
+        )
+    }
+
+}

domain/src/main/kotlin/com/wespot/message/v2/MessageV2.kt

@@ -11,6 +11,7 @@ import com.wespot.user.event.UsedAnswerFeatureEvent
 import com.wespot.user.message.AnonymousProfile
 import org.hibernate.event.internal.EventUtil
 import org.springframework.http.HttpStatus
+import java.time.LocalDate
 import java.time.LocalDateTime
 
 data class MessageV2(
@@ -47,7 +48,7 @@ data class MessageV2(
 
     companion object {
 
-        private const val COUNT_OF_MAX_ABLE_TO_SEND_MESSAGE_PER_DAY = 3
+        const val COUNT_OF_MAX_ABLE_TO_SEND_MESSAGE_PER_DAY = 3
 
         fun createInitial(
             content: String,
@@ -431,6 +432,10 @@ data class MessageV2(
         isReceiverBlockedAt = if (isReceiverBlocked) LocalDateTime.now() else null
     }
 
+    fun isSentAtSameDate(date: LocalDate): Boolean {
+        return date == createdAt.toLocalDate()
+    }
+
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
         if (other !is MessageV2) return false

infrastructure/mysql/src/main/kotlin/com/wespot/message/v2/MessageV2JpaRepository.kt

@@ -2,6 +2,7 @@ package com.wespot.message.v2
 
 import org.springframework.data.jpa.repository.JpaRepository
 import org.springframework.data.jpa.repository.Query
+import java.time.LocalDate
 import java.time.LocalDateTime
 
 interface MessageV2JpaRepository : JpaRepository<MessageJpaEntityV2, Long> {
@@ -37,4 +38,27 @@ interface MessageV2JpaRepository : JpaRepository<MessageJpaEntityV2, Long> {
         receiverId: Long,
     ): List<MessageJpaEntityV2>
 
+    @Query(
+        """
+            SELECT message
+            FROM MessageJpaEntityV2 message
+            WHERE message.receiverId = :receiverId
+                AND :from <= message.baseEntity.createdAt
+                AND message.baseEntity.createdAt = (
+                    SELECT MAX(messageInSubquery.baseEntity.createdAt)
+                    FROM MessageJpaEntityV2 messageInSubquery
+                    WHERE :from <= messageInSubquery.baseEntity.createdAt
+                        AND (
+                            (message.messageRoomId IS NOT NULL AND message.messageRoomId = messageInSubquery.messageRoomId or message.messageRoomId = messageInSubquery.id)
+                            OR
+                            (message.messageRoomId IS NULL AND message.id = messageInSubquery.messageRoomId OR message.id = messageInSubquery.id)
+                        )
+                )
+        """
+    )
+    fun findAllLastMessageOfRoomByReceiverIdAndFromDate(
+        receiverId: Long,
+        from: LocalDate
+    ): List<MessageJpaEntityV2>
+
 }

infrastructure/mysql/src/main/kotlin/com/wespot/message/v2/MessageV2PersistenceAdapter.kt

@@ -47,8 +47,8 @@ class MessageV2PersistenceAdapter(
         return getCompleteMessageV2(messageRooms)
     }
 
-    private fun getCompleteMessageV2(messageRooms: List<MessageJpaEntityV2>): List<MessageV2> {
-        val userIds: List<Long> = messageRooms.map { listOf(it.senderId, it.receiverId) }
+    private fun getCompleteMessageV2(messages: List<MessageJpaEntityV2>): List<MessageV2> {
+        val userIds: List<Long> = messages.map { listOf(it.senderId, it.receiverId) }
             .flatMap { it.asSequence() }
             .distinct()
 
@@ -60,14 +60,14 @@ class MessageV2PersistenceAdapter(
         val schoolsMap = schoolJpaRepository.findAllByIdIn(schoolIds)
             .associateBy { it.id }
 
-        val anonymousProfileIds: List<Long> = messageRooms.filter { it.anonymousProfileId != null }
+        val anonymousProfileIds: List<Long> = messages.filter { it.anonymousProfileId != null }
             .map { it.anonymousProfileId!! }
             .distinct()
         val anonymousProfiles: Map<Long, AnonymousProfileJpaEntity> =
             anonymousProfileJpaRepository.findByIdIn(anonymousProfileIds)
                 .associateBy { it.id }
 
-        return messageRooms
+        return messages
             .filter { messageRoom -> usersMap[messageRoom.senderId] != null && usersMap[messageRoom.receiverId] != null }
             .map { messageRoom ->
                 val sender = usersMap[messageRoom.senderId]!!
@@ -135,4 +135,14 @@ class MessageV2PersistenceAdapter(
         return getCompleteMessageV2(messageRooms)
     }
 
+    override fun findAllLastMessageOfRoomByReceiverIdAndFromDate(receiverId: Long, from: LocalDate): List<MessageV2> {
+        val messages =
+            messageV2JpaRepository.findAllLastMessageOfRoomByReceiverIdAndFromDate(
+                receiverId = receiverId,
+                from = from
+            )
+
+        return getCompleteMessageV2(messages = messages)
+    }
+
 }