Pair/2

local.properties

@@ -0,0 +1,8 @@
+## This file must *NOT* be checked into Version Control Systems,
+# as it contains information specific to your local configuration.
+#
+# Location of the SDK. This is only used by Gradle.
+# For customization when using a Version Control System, please read the
+# header note.
+#Wed Nov 27 15:07:01 KST 2024
+sdk.dir=/Users/jeongdaeyeong/Library/Android/sdk

src/main/kotlin/oncall/Application.kt

@@ -1,5 +1,18 @@
 package oncall
 
+import oncall.controller.OnCallController
+import oncall.domain.OnCallMonthGenerator
+import oncall.domain.OnCallWorkerGenerator
+import oncall.util.Validator
+import oncall.view.InputView
+import oncall.view.OutputView
+
 fun main() {
-    TODO("프로그램 구현")
+    val inputView = InputView()
+    val valildator = Validator()
+    val onCallMonthGenerator = OnCallMonthGenerator()
+    val onCallWorkerGenerator = OnCallWorkerGenerator()
+    val outputView = OutputView()
+    val controller = OnCallController(inputView, valildator, onCallMonthGenerator, onCallWorkerGenerator, outputView)
+    controller.run()
 }

src/main/kotlin/oncall/controller/OnCallController.kt

@@ -0,0 +1,56 @@
+package oncall.controller
+
+import oncall.domain.OnCallMonthGenerator
+import oncall.domain.OnCallWorkerGenerator
+import oncall.model.OnCallWorkSchedule
+import oncall.model.Week
+import oncall.model.Worker
+import oncall.util.Validator
+import oncall.util.retryInput
+import oncall.view.InputView
+import oncall.view.OutputView
+
+class OnCallController(
+    private val inputView: InputView,
+    private val validator: Validator,
+    private val onCallMonthGenerator: OnCallMonthGenerator,
+    private val onCallWorkerGenerator: OnCallWorkerGenerator,
+    private val outputView: OutputView
+) {
+
+    private val onCallWorkSchedule = OnCallWorkSchedule()
+
+    fun run() {
+        val (month, week) = inputMonthAndStartDayOfWeek()
+        val initializedOnCallMonth = onCallMonthGenerator.generateOnCallMonth(month, week)
+        val (weekForce, weekendForce) = inputWeekdaysWorkforce()
+        val result = onCallWorkerGenerator.generateOnCallWorker(
+            initializedOnCallMonth.toMutableList(),
+            weekForce.map { Worker(name = it) }.toMutableList(),
+            weekendForce.map { Worker(name = it) }.toMutableList()
+        )
+        onCallWorkSchedule.updateResult(result)
+        outputView.printOnCallWorkSchedule(onCallWorkSchedule)
+    }
+
+    private fun inputMonthAndStartDayOfWeek(): Pair<Int, Week> {
+        return retryInput {
+            val monthAndStartDayOfWeek = inputView.inputMonthAndStartDayOfWeek()
+            return@retryInput validator.validateInputMonthAndStartDayOfWeek(monthAndStartDayOfWeek)
+        }
+    }
+
+    private fun inputWeekdaysWorkforce(): Pair<List<String>, List<String>> {
+        return retryInput {
+            val weekWorkforce = inputView.inputWeekdaysWorkforce()
+            val weekendWorkforce = inputView.inputWeekendsWorkforce()
+            val validatedWeekWorkForce = validator.validateInputWorkforce(weekWorkforce)
+            val validatedWeekendWorkForce = validator.validateInputWorkforce(weekendWorkforce)
+            validator.validateWeekAndWeekendScehdule(
+                validatedWeekWorkForce.toSet(),
+                validatedWeekendWorkForce.toSet()
+            )
+            return@retryInput Pair(validatedWeekWorkForce, validatedWeekendWorkForce)
+        }
+    }
+}

src/main/kotlin/oncall/domain/OnCallMonthGenerator.kt

@@ -0,0 +1,36 @@
+package oncall.domain
+
+import oncall.model.DailyOnCall
+import oncall.model.Holiday
+import oncall.model.MonthlyStartAndEndDay
+import oncall.model.Week
+
+class OnCallMonthGenerator {
+    fun generateOnCallMonth(month: Int, startDay: Week): List<DailyOnCall> {
+        val result = mutableListOf<DailyOnCall>()
+        val week = Week.entries
+        var index = Week.entries.indexOf(startDay)
+        val targetMonth = MonthlyStartAndEndDay.entries.get(month - 1)
+        for (date in targetMonth.start..targetMonth.end) {
+            val isHoliday = isHoliday(month, date)
+            val day = week.get(index)
+            result.add(DailyOnCall(month, date, day, null, isHoliday(month, date), isWeekendAndHoliday(isHoliday, day)))
+            index = (index + 1) % week.size
+        }
+        return result
+    }
+
+    fun isHoliday(month: Int, date: Int): Boolean {
+        Holiday.entries.forEach {
+            if (it.month == month && it.date == date) {
+                return true
+            }
+        }
+        return false
+    }
+
+    fun isWeekendAndHoliday(isHoliday: Boolean, day: Week): Boolean {
+        return isHoliday == true || day in listOf(Week.SAT, Week.SUN)
+    }
+}
+

src/main/kotlin/oncall/domain/OnCallWorkerGenerator.kt

@@ -0,0 +1,95 @@
+package oncall.domain
+
+import oncall.model.DailyOnCall
+import oncall.model.Worker
+
+class OnCallWorkerGenerator {
+
+    fun generateOnCallWorker(
+        workSchedule: MutableList<DailyOnCall>,
+        weekForce: MutableList<Worker>,
+        weekendForce: MutableList<Worker>,
+    ): List<DailyOnCall> {
+        var previousWorker: Worker? = null
+        return workSchedule.map {
+            val currentWorker = getCurrentWorker(
+                previousWorker,
+                it.isWeekendAndHoliday,
+                weekendForce,
+                weekForce
+            )
+
+            val workers =
+                getWeekendsOrWeekdaysWorkers(it.isWeekendAndHoliday, weekendForce, weekForce)
+
+            workers.add(currentWorker)
+            previousWorker = currentWorker
+            it.copy(worker = currentWorker)
+        }
+    }
+
+    private fun getCurrentWorker(
+        previousWorker: Worker?,
+        isWeekendAndHoliday: Boolean,
+        weekendForce: MutableList<Worker>,
+        weekForce: MutableList<Worker>,
+    ): Worker {
+        val willCurrentWorker = getWillCurrentWorker(isWeekendAndHoliday, weekendForce, weekForce)
+        return generateBackupWorker(
+            previousWorker == willCurrentWorker,
+            willCurrentWorker,
+            isWeekendAndHoliday,
+            weekendForce,
+            weekForce
+        )
+    }
+
+    private fun getWillCurrentWorker(
+        isWeekendAndHoliday: Boolean,
+        weekendForce: MutableList<Worker>,
+        weekForce: MutableList<Worker>,
+    ): Worker {
+        if (isWeekendAndHoliday) {
+            return weekendForce.removeFirst()
+        }
+        return weekForce.removeFirst()
+    }
+
+    private fun generateBackupWorker(
+        isIdenticalWorker: Boolean,
+        currentWorker: Worker,
+        isWeekendAndHoliday: Boolean,
+        weekendForce: MutableList<Worker>,
+        weekForce: MutableList<Worker>,
+    ): Worker {
+        if (isIdenticalWorker) {
+            return popNextWorker(currentWorker, isWeekendAndHoliday, weekendForce, weekForce)
+        }
+        return currentWorker
+    }
+
+    private fun popNextWorker(
+        currentWorker: Worker,
+        isWeekendAndHoliday: Boolean,
+        weekendForce: MutableList<Worker>,
+        weekForce: MutableList<Worker>,
+    ): Worker {
+        val workers = getWeekendsOrWeekdaysWorkers(isWeekendAndHoliday, weekendForce, weekForce)
+        val currentAssignWorker = workers.removeFirst()
+        workers.add(FIRST_INDEX, currentWorker)
+        return currentAssignWorker
+    }
+
+    private fun getWeekendsOrWeekdaysWorkers(
+        isWeekendAndHoliday: Boolean,
+        weekendForce: MutableList<Worker>,
+        weekForce: MutableList<Worker>,
+    ): MutableList<Worker> {
+        if (isWeekendAndHoliday) return weekendForce
+        return weekForce
+    }
+
+    companion object {
+        const val FIRST_INDEX = 0
+    }
+}

src/main/kotlin/oncall/model/DailyOnCall.kt

@@ -0,0 +1,10 @@
+package oncall.model
+
+data class DailyOnCall(
+    val month: Int,
+    val date: Int,
+    val dayOfWeek: Week,
+    val worker: Worker?,
+    val isHoliday: Boolean, //(휴일) 표시를 넣기 위한 지표
+    val isWeekendAndHoliday: Boolean //법정공휴일 근무자
+)

src/main/kotlin/oncall/model/Holiday.kt

@@ -0,0 +1,5 @@
+package oncall.model
+
+enum class Holiday(val month: Int, val date: Int) {
+    신정(1, 1), 삼일절(3, 1), 어린이날(5, 5), 현충일(6, 6), 광복절(8, 15), 개천절(10, 3), 한글날(10, 9), 성탄절(12, 25)
+}

src/main/kotlin/oncall/model/MonthlyStartAndEndDay.kt

@@ -0,0 +1,9 @@
+package oncall.model
+
+enum class MonthlyStartAndEndDay(val start: Int, val end: Int) {
+    JAN(1, 31), FEB(1, 28), MAR(1, 31), APR(1, 30), MAY(1, 31), JUN(1, 30), JUL(1, 31), AUG(1, 31), SEP(1, 30), OCT(
+        1,
+        31
+    ),
+    NOB(1, 30), DEC(1, 31)
+}

src/main/kotlin/oncall/model/OnCallWorkSchedule.kt

@@ -0,0 +1,13 @@
+package oncall.model
+
+class OnCallWorkSchedule {
+    private val onCallWorkSchedule: MutableList<DailyOnCall> = mutableListOf()
+
+    fun updateResult(initializedSchedule: List<DailyOnCall>) {
+        onCallWorkSchedule.addAll(initializedSchedule)
+    }
+
+    fun getResult(): List<DailyOnCall> {
+        return onCallWorkSchedule
+    }
+}

src/main/kotlin/oncall/model/Week.kt

@@ -0,0 +1,5 @@
+package oncall.model
+
+enum class Week(val dayName: String) {
+    SUN("일"), MON("월"), TUE("화"), WED("수"), THU("목"), FRI("금"), SAT("토")
+}

src/main/kotlin/oncall/model/Worker.kt

@@ -0,0 +1,3 @@
+package oncall.model
+
+data class Worker(val name: String)

src/main/kotlin/oncall/util/Validator.kt

@@ -0,0 +1,70 @@
+package oncall.util
+
+import oncall.model.Week
+
+class Validator {
+
+    fun validateInputMonthAndStartDayOfWeek(input: String): Pair<Int, Week> {
+        val i = input.replace(" ", "").split(",")
+        val month = validateInputMonth(i[0])
+        val week = validateInputStartDayOfWeek(i[1])
+        return month to week
+    }
+
+    fun validateInputWorkforce(input: String): List<String> {
+        val workforce = input.replace(" ", "").split(",")
+        validateWorkForceSize(workforce)
+        validateInputWorkersNameLength(workforce)
+        validateIdenticalName(workforce)
+        return workforce
+    }
+
+    private fun validateWorkForceSize(workforce: List<String>) {
+        require(workforce.size in 5..35) { ERROR_MSG_OUT_OF_RANGE_IN_WORKERS }
+    }
+
+    private fun validateInputMonth(input: String): Int {
+        val month = requireNotNull(input.toIntOrNull()) {
+            ERROR_MSG_CAN_INPUT_ONLY_NUMBER
+        }
+        require(month in 1..12) {
+            ERROR_MSG_OUT_OF_RANGE_IN_MONTH
+        }
+        return month
+    }
+
+    private fun validateInputStartDayOfWeek(input: String) =
+        requireNotNull(Week.entries.find { it.dayName == input }) {
+            ERROR_MSG_OUT_OF_RANGE_IN_WEEK_OF_DAY
+        }
+
+    private fun validateInputWorkersNameLength(workforce: List<String>) {
+        workforce.forEach { name ->
+            require(name.length <= 5) {
+                ERROR_MSG_CAN_INPUT_FIVE_LENGTH
+            }
+        }
+    }
+
+    private fun validateIdenticalName(workForce: List<String>) {
+        val set = workForce.toSet()
+        require(set.size == workForce.size) { ERROR_MSG_CANNOT_INPUT_DUPLICATE_NAME }
+    }
+
+    //모든 구성원의 근무가 평일, 휴일 모두 들어가 있는지 확인
+    fun validateWeekAndWeekendScehdule(weekWorkforce: Set<String>, weekendWorkforce: Set<String>) {
+        require(weekWorkforce == weekendWorkforce) { ERROR_MSG_NOT_IDENTICAL_WORKERS_SET }
+    }
+
+    companion object {
+        const val ERROR_MSG_OUT_OF_RANGE_IN_WORKERS = "[ERROR] 근무자는 5명에서 35명으로 작성해야합니다."
+        const val ERROR_MSG_CAN_INPUT_ONLY_NUMBER = "[ERROR] 월은 숫자만 입력이 가능합니다."
+        const val ERROR_MSG_OUT_OF_RANGE_IN_MONTH = "[ERROR] 1~12까지의 월 입력이 가능합니다."
+        const val ERROR_MSG_OUT_OF_RANGE_IN_WEEK_OF_DAY = "[ERROR] 일, 월, 화, 수, 목, 금, 토 요일 입력이 가능합니다."
+        const val ERROR_MSG_CAN_INPUT_FIVE_LENGTH = "[ERROR] 이름은 최대 5자리까지 가능합니다."
+        const val ERROR_MSG_CANNOT_INPUT_DUPLICATE_NAME = "[ERROR] 중복된 닉네임은 불가합니다."
+        const val ERROR_MSG_NOT_IDENTICAL_WORKERS_SET = "[ERROR] 모든 근무자는 평일, 휴일 모두 근무해야합니다"
+
+
+    }
+}

src/main/kotlin/oncall/util/retryInput.kt

@@ -0,0 +1,11 @@
+package oncall.util
+
+fun <T>retryInput(input:() -> T): T {
+    while (true) {
+        try {
+            return input()
+        } catch (e: Exception) {
+            println("Error: ${e.message}")
+        }
+    }
+}

src/main/kotlin/oncall/view/InputView.kt

@@ -0,0 +1,27 @@
+package oncall.view
+
+import camp.nextstep.edu.missionutils.Console
+
+class InputView {
+
+    fun inputMonthAndStartDayOfWeek(): String {
+        print(INPUT_MONTH_AND_START_DAY_OF_WEEK)
+        return Console.readLine()
+    }
+
+    fun inputWeekdaysWorkforce(): String {
+        print(INPUT_WEEKDAYS_WORKFORCE)
+        return Console.readLine()
+    }
+
+    fun inputWeekendsWorkforce(): String {
+        print(INPUT_WEEKENDS_WORKFORCE)
+        return Console.readLine()
+    }
+
+    companion object {
+        const val INPUT_MONTH_AND_START_DAY_OF_WEEK = "비상 근무를 배정할 월과 시작 요일을 입력하세요> "
+        const val INPUT_WEEKDAYS_WORKFORCE = "평일 비상 근무 순번대로 사원 닉네임을 입력하세요> "
+        const val INPUT_WEEKENDS_WORKFORCE = "주말 비상 근무 순번대로 사원 닉네임을 입력하세요> "
+    }
+}

src/main/kotlin/oncall/view/OutputView.kt

@@ -0,0 +1,13 @@
+package oncall.view
+
+import oncall.model.OnCallWorkSchedule
+
+class OutputView {
+    fun printOnCallWorkSchedule(onCallWorkerSchedule: OnCallWorkSchedule) {
+        onCallWorkerSchedule.getResult().forEach {
+            //5월 5일 금(휴일) 루루
+            val holidayMark = if (it.isHoliday) "(휴일)" else ""
+            println("${it.month}월 ${it.date}일 ${it.dayOfWeek.dayName}${holidayMark} ${it.worker?.name}")
+        }
+    }
+}