feat(mail): implement mail reservation

src/main/kotlin/apply/application/mail/MailData.kt

@@ -1,6 +1,7 @@
 package apply.application.mail
 
 import apply.domain.mail.MailHistory
+import apply.domain.mail.MailMessage
 import org.springframework.core.io.ByteArrayResource
 import java.time.LocalDateTime
 import javax.validation.constraints.NotEmpty
@@ -30,12 +31,25 @@ data class MailData(
     @field:NotNull
     var id: Long = 0L
 ) {
-    constructor(mailHistory: MailHistory) : this(
-        mailHistory.subject,
-        mailHistory.body,
-        mailHistory.sender,
+    constructor(mailMessage: MailMessage) : this(
+        mailMessage.subject,
+        mailMessage.body,
+        mailMessage.sender,
+        mailMessage.recipients,
+        id = mailMessage.id
+    )
+
+    constructor(mailMessage: MailMessage, mailHistory: MailHistory) : this(
+        mailMessage.subject,
+        mailMessage.body,
+        mailMessage.sender,
         mailHistory.recipients,
         mailHistory.sentTime,
         id = mailHistory.id
     )
+
+    fun toMailMessage(): MailMessage {
+        // TODO: 작성자 ID 바인딩
+        return MailMessage(subject, body, sender, recipients, 1L)
+    }
 }

src/main/kotlin/apply/application/mail/MailDtos.kt

@@ -0,0 +1,65 @@
+package apply.application.mail
+
+import apply.domain.mail.MailHistory
+import apply.domain.mail.MailMessage
+import apply.domain.mail.MailReservation
+import apply.domain.mail.MailReservationStatus
+import java.time.LocalDateTime
+
+data class MailMessageResponse(
+    val id: Long,
+    val subject: String,
+    val body: String,
+    val sender: String,
+    val recipients: List<String>,
+    val createdDateTime: LocalDateTime,
+    val sentTime: LocalDateTime?,
+    val reservation: MailReservationResponse?,
+    val histories: List<MailHistoryResponse>
+) {
+    constructor(
+        mailMessage: MailMessage,
+        mailReservation: MailReservation? = null,
+        mailHistories: List<MailHistory> = emptyList()
+    ) : this(
+        mailMessage.id,
+        mailMessage.subject,
+        mailMessage.body,
+        mailMessage.sender,
+        mailMessage.recipients,
+        mailMessage.createdDateTime,
+        mailHistories.firstOrNull()?.sentTime,
+        mailReservation?.let { MailReservationResponse(it) },
+        mailHistories.map { MailHistoryResponse(it) }
+    )
+}
+
+data class MailReservationResponse(
+    val id: Long,
+    val mailMessageId: Long,
+    val status: MailReservationStatus,
+    val reservationTime: LocalDateTime
+) {
+    constructor(mailReservation: MailReservation) : this(
+        mailReservation.id,
+        mailReservation.mailMessageId,
+        mailReservation.status,
+        mailReservation.reservationTime
+    )
+}
+
+data class MailHistoryResponse(
+    val id: Long,
+    val mailMessageId: Long,
+    val recipients: List<String>,
+    val success: Boolean,
+    val sentTime: LocalDateTime
+) {
+    constructor(mailHistory: MailHistory) : this(
+        mailHistory.id,
+        mailHistory.mailMessageId,
+        mailHistory.recipients,
+        mailHistory.success,
+        mailHistory.sentTime
+    )
+}

src/main/kotlin/apply/application/mail/MailHistoryService.kt

@@ -0,0 +1,26 @@
+package apply.application.mail
+
+import apply.domain.mail.MailHistoryRepository
+import apply.domain.mail.MailMessageRepository
+import apply.domain.mail.getOrThrow
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Transactional
+@Service
+class MailHistoryService(
+    private val mailHistoryRepository: MailHistoryRepository,
+    private val mailMessageRepository: MailMessageRepository
+) {
+    fun findAll(): List<MailData> {
+        val histories = mailHistoryRepository.findAll()
+        val messagesById = mailMessageRepository.findAllById(histories.map { it.mailMessageId }).associateBy { it.id }
+        return histories.map { MailData(messagesById.getValue(it.mailMessageId), it) }
+    }
+
+    fun getById(mailHistoryId: Long): MailData {
+        val mailHistory = mailHistoryRepository.getOrThrow(mailHistoryId)
+        val mailMessage = mailMessageRepository.getOrThrow(mailHistory.mailMessageId)
+        return MailData(mailMessage, mailHistory)
+    }
+}

src/main/kotlin/apply/application/mail/MailMessageService.kt

@@ -0,0 +1,82 @@
+package apply.application.mail
+
+import apply.domain.mail.MailHistoryRepository
+import apply.domain.mail.MailMessage
+import apply.domain.mail.MailMessageRepository
+import apply.domain.mail.MailReservation
+import apply.domain.mail.MailReservationRepository
+import apply.domain.mail.MailReservationStatus
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import java.time.LocalDateTime
+
+@Service
+class MailMessageService(
+    private val sendingMailService: SendingMailService,
+    private val mailMessageRepository: MailMessageRepository,
+    private val mailReservationRepository: MailReservationRepository,
+    private val mailHistoryRepository: MailHistoryRepository
+) {
+    fun findSentMails(): List<MailMessageResponse> {
+        val histories = mailHistoryRepository.findAll()
+        val messagesById = findMessageMapById(histories.map { it.mailMessageId })
+        return messagesById.map { (id, message) ->
+            MailMessageResponse(
+                mailMessage = message,
+                mailHistories = histories.filter { it.mailMessageId == id }
+            )
+        }
+    }
+
+    fun findReservedMails(): List<MailMessageResponse> {
+        val reservations = mailReservationRepository.findByStatus(MailReservationStatus.WAITING)
+        val messagesById = findMessageMapById(reservations.map { it.mailMessageId })
+
+        return reservations
+            .filter { messagesById.contains(it.mailMessageId) }
+            .map {
+                MailMessageResponse(
+                    mailMessage = messagesById.getValue(it.mailMessageId),
+                    mailReservation = it
+                )
+            }
+    }
+
+    @Transactional
+    fun reserve(request: MailData): MailMessageResponse {
+        val mailMessage = mailMessageRepository.save(request.toMailMessage())
+        val mailReservation = mailReservationRepository.save(
+            MailReservation(mailMessageId = mailMessage.id, reservationTime = request.sentTime)
+        )
+        return MailMessageResponse(mailMessage, mailReservation)
+    }
+
+    @Transactional
+    fun cancelReservation(mailMessageId: Long) {
+        val mailReservation = mailReservationRepository.findByMailMessageId(mailMessageId)
+            ?: throw IllegalArgumentException("메일 예약이 존재하지 않습니다. email: $mailMessageId")
+        check(mailReservation.canCancel()) { "예약 취소할 수 없는 메일입니다." }
+        mailReservationRepository.deleteById(mailReservation.id)
+        mailMessageRepository.deleteById(mailReservation.mailMessageId)
+    }
+
+    fun sendReservedMails(standardTime: LocalDateTime = LocalDateTime.now()) {
+        val reservations = mailReservationRepository.findByReservationTimeBeforeAndStatus(
+            standardTime,
+            MailReservationStatus.WAITING
+        )
+        val messagesById = findMessageMapById(reservations.map { it.mailMessageId })
+
+        reservations.forEach { mailReservation ->
+            sendingMailService.sendMailByBccSynchronous(MailData(messagesById.getValue(mailReservation.mailMessageId)))
+            mailReservation.finish()
+            mailReservationRepository.save(mailReservation)
+        }
+    }
+
+    private fun findMessageMapById(mailMessageIds: List<Long>): Map<Long, MailMessage> {
+        return mailMessageRepository
+            .findAllById(mailMessageIds)
+            .associateBy { it.id }
+    }
+}

src/main/kotlin/apply/application/mail/MailService.kt → src/main/kotlin/apply/application/mail/SendingMailService.kt

@@ -4,6 +4,7 @@ import apply.application.ApplicationProperties
 import apply.domain.applicationform.ApplicationFormSubmittedEvent
 import apply.domain.mail.MailHistory
 import apply.domain.mail.MailHistoryRepository
+import apply.domain.mail.MailMessageRepository
 import apply.domain.recruitment.RecruitmentRepository
 import apply.domain.recruitment.getOrThrow
 import apply.domain.user.PasswordResetEvent
@@ -21,9 +22,10 @@ import support.markdownToEmbeddedHtml
 private const val MAIL_SENDING_UNIT: Int = 50
 
 @Service
-class MailService(
+class SendingMailService(
     private val userRepository: UserRepository,
     private val recruitmentRepository: RecruitmentRepository,
+    private val mailMessageRepository: MailMessageRepository,
     private val mailHistoryRepository: MailHistoryRepository,
     private val applicationProperties: ApplicationProperties,
     private val templateEngine: ISpringTemplateEngine,
@@ -89,11 +91,11 @@ class MailService(
     }
 
     @Async
-    fun sendMailsByBcc(request: MailData, files: Map<String, ByteArrayResource>) {
+    fun sendMailByBcc(request: MailData, files: Map<String, ByteArrayResource>) {
+        val mailMessage = mailMessageRepository.save(request.toMailMessage())
         val body = generateMailBody(request)
         val recipients = request.recipients + mailProperties.username
 
-        // TODO: 성공과 실패를 분리하여 히스토리 관리
         val succeeded = mutableListOf<String>()
         val failed = mutableListOf<String>()
         for (addresses in recipients.chunked(MAIL_SENDING_UNIT)) {
@@ -102,15 +104,23 @@ class MailService(
                 .onFailure { failed.addAll(addresses) }
         }
 
-        mailHistoryRepository.save(
-            MailHistory(
-                request.subject,
-                request.body,
-                request.sender,
-                request.recipients,
-                request.sentTime
-            )
-        )
+        saveMailHistories(mailMessage.id, succeeded, failed)
+    }
+
+    fun sendMailByBccSynchronous(request: MailData, files: Map<String, ByteArrayResource> = emptyMap()) {
+        val mailMessage = mailMessageRepository.save(request.toMailMessage())
+        val body = generateMailBody(request)
+        val recipients = mailMessage.recipients + mailProperties.username
+
+        val succeeded = mutableListOf<String>()
+        val failed = mutableListOf<String>()
+        for (addresses in recipients.chunked(MAIL_SENDING_UNIT)) {
+            runCatching { mailSender.sendBcc(addresses, mailMessage.subject, body, files) }
+                .onSuccess { succeeded.addAll(addresses) }
+                .onFailure { failed.addAll(addresses) }
+        }
+
+        saveMailHistories(mailMessage.id, succeeded, failed)
     }
 
     fun generateMailBody(mailData: MailData): String {
@@ -124,4 +134,22 @@ class MailService(
         }
         return templateEngine.process("mail/common", context)
     }
+
+    private fun saveMailHistories(
+        mailMessageId: Long,
+        succeeded: MutableList<String>,
+        failed: MutableList<String>
+    ) {
+        val mailHistories = mutableListOf<MailHistory>()
+
+        if (succeeded.isNotEmpty()) {
+            mailHistories.add(MailHistory(mailMessageId, succeeded, true))
+        }
+
+        if (failed.isNotEmpty()) {
+            mailHistories.add(MailHistory(mailMessageId, failed, false))
+        }
+
+        mailHistoryRepository.saveAll(mailHistories)
+    }
 }

src/main/kotlin/apply/config/DatabaseInitializer.kt

@@ -22,6 +22,8 @@ import apply.domain.judgmentitem.JudgmentItemRepository
 import apply.domain.judgmentitem.ProgrammingLanguage
 import apply.domain.mail.MailHistory
 import apply.domain.mail.MailHistoryRepository
+import apply.domain.mail.MailMessage
+import apply.domain.mail.MailMessageRepository
 import apply.domain.mission.Mission
 import apply.domain.mission.MissionRepository
 import apply.domain.recruitment.Recruitment
@@ -57,6 +59,7 @@ class DatabaseInitializer(
     private val missionRepository: MissionRepository,
     private val judgmentItemRepository: JudgmentItemRepository,
     private val assignmentRepository: AssignmentRepository,
+    private val mailMessageRepository: MailMessageRepository,
     private val mailHistoryRepository: MailHistoryRepository,
     private val database: Database
 ) : CommandLineRunner {
@@ -429,13 +432,25 @@ class DatabaseInitializer(
     }
 
     private fun populateMailHistories() {
+        val mailMessage = MailMessage(
+            subject = "[우아한테크코스] 프리코스를 진행하는 목적과 사전 준비",
+            body = "안녕하세요.",
+            sender = "woowa_course@woowahan.com",
+            recipients = listOf("a@email.com", "b@email.com", "c@email.com", "d@email.com"),
+            creatorId = 1L,
+        )
+        mailMessageRepository.save(mailMessage)
+
         val mailHistories = listOf(
             MailHistory(
-                subject = "[우아한테크코스] 프리코스를 진행하는 목적과 사전 준비",
-                body = "안녕하세요.",
-                sender = "woowa_course@woowahan.com",
-                recipients = listOf("a@email.com", "b@email.com", "c@email.com", "d@email.com"),
-                sentTime = createLocalDateTime(2020, 11, 5, 10)
+                mailMessageId = mailMessage.id,
+                recipients = mailMessage.recipients.subList(0, 2),
+                success = true
+            ),
+            MailHistory(
+                mailMessageId = mailMessage.id,
+                recipients = mailMessage.recipients.subList(3, 4),
+                success = true
             )
         )
         mailHistoryRepository.saveAll(mailHistories)

src/main/kotlin/apply/domain/mail/MailHistory.kt

@@ -11,20 +11,16 @@ import javax.persistence.Lob
 @Entity
 class MailHistory(
     @Column(nullable = false)
-    val subject: String,
-
-    @Column(nullable = false)
-    @Lob
-    val body: String,
-
-    @Column(nullable = false)
-    val sender: String,
+    val mailMessageId: Long = 0L,
 
     @Column(nullable = false)
     @Convert(converter = StringToListConverter::class)
     @Lob
     val recipients: List<String>,
 
+    @Column(nullable = false)
+    val success: Boolean,
+
     @Column(nullable = false)
     val sentTime: LocalDateTime = LocalDateTime.now(),
     id: Long = 0L