결석 처리 API 및 배치 개발

moit-api/src/main/kotlin/com/mashup/moit/controller/study/StudyController.kt

@@ -1,14 +1,15 @@
 package com.mashup.moit.controller.study
 
 import com.mashup.moit.common.MoitApiResponse
-import com.mashup.moit.security.authentication.UserInfo
-import com.mashup.moit.security.resolver.GetAuth
+import com.mashup.moit.controller.study.dto.StudyAdjustAbsenceRequest
 import com.mashup.moit.controller.study.dto.StudyAttendanceKeywordRequest
 import com.mashup.moit.controller.study.dto.StudyAttendanceKeywordResponse
 import com.mashup.moit.controller.study.dto.StudyDetailsResponse
 import com.mashup.moit.controller.study.dto.StudyFirstAttendanceResponse
 import com.mashup.moit.controller.study.dto.StudyUserAttendanceStatusResponse
 import com.mashup.moit.facade.StudyFacade
+import com.mashup.moit.security.authentication.UserInfo
+import com.mashup.moit.security.resolver.GetAuth
 import io.swagger.v3.oas.annotations.Operation
 import io.swagger.v3.oas.annotations.tags.Tag
 import jakarta.validation.Valid
@@ -78,4 +79,12 @@ class StudyController(
         studyFacade.initializeAttendance(studyId)
         return MoitApiResponse.success()
     }
+
+    @Operation(summary = "Adjust Absence Status", description = "Study 결석 처리")
+    @PostMapping("/attendance/adjust/absence")
+    fun adjustAbsenceStatus(@RequestBody request: StudyAdjustAbsenceRequest): MoitApiResponse<Unit> {
+        studyFacade.adjustAbsenceStatus(request.studyIds.toSet())
+        return MoitApiResponse.success()
+
+    }
 }

moit-api/src/main/kotlin/com/mashup/moit/controller/study/dto/StudyDto.kt

@@ -93,3 +93,10 @@ data class StudyUserAttendanceStatusResponse(
         )
     }
 }
+
+@Schema(description = "Study 결석 처리 요청")
+data class StudyAdjustAbsenceRequest(
+    @Schema(description = "Study Ids")
+    @field:NotBlank
+    val studyIds: List<Long>
+)

moit-api/src/main/kotlin/com/mashup/moit/facade/StudyFacade.kt

@@ -6,6 +6,7 @@ import com.mashup.moit.controller.study.dto.StudyDetailsResponse
 import com.mashup.moit.controller.study.dto.StudyFirstAttendanceResponse
 import com.mashup.moit.controller.study.dto.StudyUserAttendanceStatusResponse
 import com.mashup.moit.domain.attendance.AttendanceService
+import com.mashup.moit.domain.fine.FineService
 import com.mashup.moit.domain.moit.MoitService
 import com.mashup.moit.domain.study.StudyService
 import com.mashup.moit.domain.user.UserService
@@ -20,6 +21,7 @@ class StudyFacade(
     private val moitService: MoitService,
     private val studyService: StudyService,
     private val attendanceService: AttendanceService,
+    private val fineService: FineService,
     private val userService: UserService,
     private val eventProducer: EventProducer
 ) {
@@ -69,4 +71,12 @@ class StudyFacade(
     fun checkFirstAttendance(studyId: Long): StudyFirstAttendanceResponse {
         return StudyFirstAttendanceResponse.of(attendanceService.existFirstAttendanceByStudyId(studyId))
     }
+
+    @Transactional
+    fun adjustAbsenceStatus(studyIds: Set<Long>) {
+        studyService.findByStudyIds(studyIds.toList()).forEach { study ->
+            attendanceService.adjustUndecidedAttendancesByStudyId(study.id)
+                .forEach { attendanceId -> fineService.create(attendanceId, study.moitId) }
+        }
+    }
 }

moit-api/src/main/kotlin/com/mashup/moit/infra/event/MoitEvent.kt

@@ -16,6 +16,12 @@ data class StudyAttendanceEvent(val attendanceId: Long, val moitId: Long) : Moit
     }
 }
 
+data class StudyAttendanceEventBulk(val attendanceIdWithMoitIds: List<Pair<Long, Long>>) : MoitEvent {
+    override fun getTopic(): String {
+        return KafkaEventTopic.STUDY_ATTENDANCE_BULK
+    }
+}
+
 data class StudyInitializeEvent(val studyId: Long) : MoitEvent {
     override fun getTopic(): String {
         return KafkaEventTopic.STUDY_INITIALIZE
@@ -28,6 +34,12 @@ data class FineCreateEvent(val fineId: Long) : MoitEvent {
     }
 }
 
+data class FineCreateEventBulk(val fineIds: Set<Long>) : MoitEvent {
+    override fun getTopic(): String {
+        return KafkaEventTopic.FINE_CREATE_BULK
+    }
+}
+
 data class FineApproveEvent(val fineId: Long) : MoitEvent {
     override fun getTopic(): String {
         return KafkaEventTopic.FINE_APPROVE

moit-api/src/main/kotlin/com/mashup/moit/infra/event/MoitEventTopic.kt

@@ -4,14 +4,18 @@ object KafkaEventTopic {
     const val MOIT_CREATE = "moit_create"
     const val STUDY_INITIALIZE = "study_initialize"
     const val STUDY_ATTENDANCE = "study_attendance"
+    const val STUDY_ATTENDANCE_BULK = "study_attendance_bulk"
     const val FINE_CREATE = "fine_create"
+    const val FINE_CREATE_BULK = "fine_create_bulk"
     const val FINE_APPROVE = "fine_approve"
 }
 
 object KafkaConsumerGroup {
     const val MOIT_CREATE_STUDY_CREATE = "moit_create_study_create"
     const val STUDY_INITIALIZE_BANNER_UPDATE = "study_initialize_banner_update"
     const val STUDY_ATTENDANCE_FINE_CREATE = "study_attendance_fine_create"
+    const val STUDY_ATTENDANCE_FINE_CREATE_BULK = "study_attendance_fine_create_bulk"
     const val FINE_CREATE_BANNER_UPDATE = "fine_create_banner_update"
+    const val FINE_CREATE_BANNER_UPDATE_BULK = "fine_create_banner_update_bulk"
     const val FINE_APPROVE_BANNER_UPDATE = "fine_approve_banner_update"
 }

moit-api/src/main/kotlin/com/mashup/moit/infra/event/kafka/KafkaConsumer.kt

@@ -8,10 +8,12 @@ import com.mashup.moit.domain.study.StudyService
 import com.mashup.moit.infra.event.EventProducer
 import com.mashup.moit.infra.event.FineApproveEvent
 import com.mashup.moit.infra.event.FineCreateEvent
-import com.mashup.moit.infra.event.StudyAttendanceEvent
+import com.mashup.moit.infra.event.FineCreateEventBulk
 import com.mashup.moit.infra.event.KafkaConsumerGroup
 import com.mashup.moit.infra.event.KafkaEventTopic
 import com.mashup.moit.infra.event.MoitCreateEvent
+import com.mashup.moit.infra.event.StudyAttendanceEvent
+import com.mashup.moit.infra.event.StudyAttendanceEventBulk
 import com.mashup.moit.infra.event.StudyInitializeEvent
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
@@ -56,6 +58,19 @@ class KafkaConsumer(
         }
     }
 
+    @KafkaListener(
+        topics = [KafkaEventTopic.STUDY_ATTENDANCE_BULK],
+        groupId = KafkaConsumerGroup.STUDY_ATTENDANCE_FINE_CREATE_BULK,
+    )
+    fun consumeStudyAttendancesEvent(event: StudyAttendanceEventBulk) {
+        log.debug("consumeStudyAttendancesEventBulk called: {}", event)
+        val fineIds = mutableSetOf<Long>()
+        event.attendanceIdWithMoitIds.forEach { (attendanceId, moitId) ->
+            fineService.create(attendanceId, moitId)?.let { fine -> fineIds.add(fine.id) }
+        }
+        eventProducer.produce(FineCreateEventBulk(fineIds))
+    }
+
     @KafkaListener(
         topics = [KafkaEventTopic.FINE_CREATE],
         groupId = KafkaConsumerGroup.FINE_CREATE_BANNER_UPDATE,
@@ -65,6 +80,17 @@ class KafkaConsumer(
         bannerService.update(MoitUnapprovedFineExistBannerUpdateRequest(event.fineId))
     }
 
+    @KafkaListener(
+        topics = [KafkaEventTopic.FINE_CREATE_BULK],
+        groupId = KafkaConsumerGroup.FINE_CREATE_BANNER_UPDATE_BULK,
+    )
+    fun consumeFineCreateEventBulk(event: FineCreateEventBulk) {
+        log.debug("consumeFineCreateEventBulk called: {}", event)
+        event.fineIds.forEach { fineId ->
+            bannerService.update(MoitUnapprovedFineExistBannerUpdateRequest(fineId))
+        }
+    }
+
     @KafkaListener(
         topics = [KafkaEventTopic.FINE_APPROVE],
         groupId = KafkaConsumerGroup.FINE_APPROVE_BANNER_UPDATE,

moit-api/src/main/kotlin/com/mashup/moit/scheduler/StudyAdjustAbsenceScheduler.kt

@@ -0,0 +1,48 @@
+package com.mashup.moit.scheduler
+
+import com.mashup.moit.domain.attendance.AttendanceService
+import com.mashup.moit.domain.study.StudyService
+import com.mashup.moit.infra.event.EventProducer
+import com.mashup.moit.infra.event.StudyAttendanceEventBulk
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import org.springframework.scheduling.annotation.Async
+import org.springframework.scheduling.annotation.Scheduled
+import org.springframework.stereotype.Component
+import org.springframework.transaction.annotation.Transactional
+import java.time.LocalDateTime
+
+@Component
+class StudyAdjustAbsenceScheduler(
+    private val studyService: StudyService,
+    private val attendanceService: AttendanceService,
+    private val eventProducer: EventProducer
+) {
+    val logger: Logger = LoggerFactory.getLogger(StudyAdjustAbsenceScheduler::class.java)
+
+    @Scheduled(cron = "0 */5 * * * *")
+    @Async("asyncSchedulerExecutor")
+    @Transactional
+    fun adjustAbsenceStatusFromNow() {
+        // 결석 확정을 지을 때 endAt을 현재 시간보다 15초 정도 유예기간을 줌. 5분마다 배치가 돌기 때문에 95% 시간 내에 끝난 스터디를 반환함
+        val scheduleContext = LocalDateTime.now()
+        val undecided = studyService
+            .findUnfinalizedStudiesByEndAtBefore(scheduleContext.minusSeconds(DECIDE_ABSENCE_RANGE_SECONDS))
+        logger.info("{} undecided studies start! Start adjusting absence status at {}.", undecided.size, scheduleContext)
+
+        val attendanceIdWithMoitIds = mutableListOf<Pair<Long, Long>>()
+        undecided.forEach { study ->
+            attendanceIdWithMoitIds.addAll(
+                attendanceService.adjustUndecidedAttendancesByStudyId(study.id)
+                    .map { attendanceId -> attendanceId to study.moitId }
+            )
+        }
+        eventProducer.produce(StudyAttendanceEventBulk(attendanceIdWithMoitIds))
+
+        logger.info("Done adjusting absence status for {} studies, at {}", undecided.size, LocalDateTime.now())
+    }
+
+    companion object {
+        private const val DECIDE_ABSENCE_RANGE_SECONDS = 15L
+    }
+}

moit-domain/src/main/kotlin/com/mashup/moit/domain/attendance/AttendanceRepository.kt

@@ -7,5 +7,6 @@ import org.springframework.stereotype.Repository
 interface AttendanceRepository : JpaRepository<AttendanceEntity, Long> {
     fun findByUserIdAndStudyId(userId: Long, studyId: Long): AttendanceEntity?
     fun findAllByStudyIdOrderByAttendanceAtAsc(studyId: Long): List<AttendanceEntity>
+    fun findAllByStudyIdAndStatus(studyId: Long, status: AttendanceStatus): List<AttendanceEntity>
     fun existsByStudyIdAndStatus(studyId: Long, status: AttendanceStatus): Boolean
 }

moit-domain/src/main/kotlin/com/mashup/moit/domain/attendance/AttendanceService.kt

@@ -59,4 +59,11 @@ class AttendanceService(
     fun existFirstAttendanceByStudyId(studyId: Long): Boolean {
         return attendanceRepository.existsByStudyIdAndStatus(studyId, AttendanceStatus.ATTENDANCE)
     }
+
+    @Transactional
+    fun adjustUndecidedAttendancesByStudyId(studyId: Long, status: AttendanceStatus = AttendanceStatus.ABSENCE): List<Long> {
+        val attendances = attendanceRepository.findAllByStudyIdAndStatus(studyId, AttendanceStatus.UNDECIDED)
+        attendances.forEach { attendance -> attendance.status = status }
+        return attendances.map { it.id }
+    }
 }

moit-domain/src/main/kotlin/com/mashup/moit/domain/study/StudyEntity.kt

@@ -40,6 +40,9 @@ class StudyEntity(
     @Column(name = "is_initialized", nullable = false)
     var isInitialized: Boolean = false
 
+    @Column(name = "is_finalized", nullable = false)
+    var isFinalized: Boolean = false
+
     fun toDomain() = Study(
         id = id,
         moitId = moitId,

moit-domain/src/main/kotlin/com/mashup/moit/domain/study/StudyRepository.kt

@@ -10,6 +10,7 @@ interface StudyRepository : JpaRepository<StudyEntity, Long> {
     // findAll By StartAtBefore And IsInitializedFalse
     fun findAllByStartAtBeforeAndIsInitializedFalse(startAt: LocalDateTime): List<StudyEntity>
     fun findAllByMoitIdAndStartAtBeforeOrderByOrderDesc(moitId: Long, startAt: LocalDateTime): List<StudyEntity>
+    fun findAllByEndAtBeforeAndIsFinalizedFalse(endAt: LocalDateTime): List<StudyEntity>
 
     // findAll By minDt <= StartAt <= maxDt (cause: Between Index performance degradation)
     fun findAllByStartAtGreaterThanEqualAndStartAtLessThanEqual(minStartAt: LocalDateTime, maxStartAt: LocalDateTime): List<StudyEntity>

moit-domain/src/main/kotlin/com/mashup/moit/domain/study/StudyService.kt

@@ -113,4 +113,9 @@ class StudyService(
             .filter { !it.isInitialized } // 모종의 initialize 실패 인입 방지 
             .map { it.toDomain() }
     }
+
+    fun findUnfinalizedStudiesByEndAtBefore(endAt: LocalDateTime): List<Study> {
+        return studyRepository.findAllByEndAtBeforeAndIsFinalizedFalse(endAt)
+            .map { it.toDomain() }
+    }
 }