[2단계 - 출석 다시 구현하기] 다로(이정민) 미션 제출합니다.

README.md

@@ -1,34 +1,66 @@
 # java-attendance
 
 ## 기능 목록
+- [X] src/main/resources/attendances.csv 파일을 이용하여 필요한 정보를 가져와 저장한다.
 - [X] 1번을 눌렀을 경우
     - [X] 닉네임을 입력받는다.
     - [X] 등교 시간을 입력받는다. (등교시간의 경우 오늘 등교를 하는 것이나 12월 이라는 조건으로 오늘을 2024.12.13 으로 설정하였습니다)
-    - [X] 정보를 업데이트 하고, 출력한다.
+    - [X] 요일별 등교 시간을 확인한다.
+    - [X] 요일별 등교 시간을 기반으로 입력 받은 등교 시간과 비교하여 출석, 지각, 결석을 판단한다.
+    - [X] 출결 정보를 등록
+    - [X] 등록한 정보 출력한다.
 - [X] 2번을 눌렀을 경우
     - [X] 닉네임을 입력받는다. 
     - [X] 날짜를 입력받는다.
     - [X] 변경할 시간을 입력받는다.
-    - [X] 정보를 업데이트 하고, 출력한다.
+    - [X] 변경한 시간을 기반으로 출석, 지각, 결석을 판단한다.
+    - [X] 정보를 수정한다.
+    - [X] 바뀐 정보를 출력한다.
 - [X] 3번을 눌렀을 경우
     - [X] 닉네임을 입력받는다.
-    - [X] 출석 기록을 출력한다.
+    - [X] 오늘을 기준으로 그 전 날짜들의 출석 기록이 없는 경우 결석으로 처리한다. 
+    - [X] 입력 받은 크루의 출석 기록을 출력한다.
 - [X] 4번을 눌렀을 경우
-    - [X] 제적 위험자를 출력한다.
+    - [X] 크루들의 출석 기록들을 확인한다.
+    - [X] 크루들의 출결 기록 횟수들을 계산한다.
+    - [X] 지각 3회는 결석 1회로 간주하여 계산한다.
+    - [X] 제적 위험자 조건에 맞는 크루들을 찾는다.
+    - [X] 출력한다.
 - [X] Q를 눌렀을 경우
     - [X] 프로그램을 종료한다.
 ---
+## 예외 처리
+- [X] 존재하지 않는 닉네임을 입력한 경우
+- [X] 존재하지 않는 기록을 수정하려고 할 경우
+- [X] 메뉴 선택이 잘못된 경우
+- [X] 등교 시간을 잘못 적은
+  - [X] 잘못된 형식으로 입력한 경우
+  - [X] 캠퍼스 운영 시간이 아닌 경우
+  - [X] 주말 및 공휴일에 출석을 한 경우
+  - [X] 이미 출석한 경우
+---
 ## 요구 사항
 -  2024년 12월 한 달 동안 시범적으로 최소한의 기능을 갖춘 출석 시스템입니다.
 -  교육 시작 시간으로부터 5분 초과 시 지각
 -  교육 시작 시간으로부터 30분 초과 시 결석
 -  지각 3회는 결석 1회로 간주한다.
--  결석 5회 초과는 제적 대상자.
----
-## 예외 처리
-- [X] 존재하지 않는 닉네임을 입력한 경우 - 
-- [X] 등교 시간을 잘못 적은 경우
-    - [X] 잘못된 형식으로 입력한 경우 
-    - [X] 캠퍼스 운영 시간이 아닌 경우
-    - [X] 주말 및 공휴일에 출석을 한 경우
+-  경고 대상자: 결석 2회 이상 
+-  면담 대상자: 결석 3회 이상 
+-  제적 대상자: 결석 5회 초과
+-  구현 요구사항을 만족하는 최소한의 설계를 한다.
 ---
+## 프로그래밍 요구 사항
+- 자바 코드 컨벤션을 지키면서 프로그래밍한다. (기본적으로 Java Style Guide을 원칙으로 한다.)
+- indent(인덴트, 들여쓰기) depth를 2를 넘지 않도록 구현한다. 1까지만 허용한다.
+- 3항 연산자를 쓰지 않는다.
+- else 예약어를 쓰지 않는다. (else 예약어를 쓰지 말라고 하니 switch/case로 구현하는 경우가 있는데 switch/case도 허용하지 않는다.)
+- 모든 기능을 TDD로 구현해 단위 테스트가 존재해야 한다. 단, UI(System.out, System.in) 로직은 제외
+- 핵심 로직을 구현하는 코드와 UI를 담당하는 로직을 구분한다.
+- UI 로직을 InputView, ResultView와 같은 클래스를 추가해 분리한다.
+- 함수(또는 메서드)의 길이가 10라인을 넘어가지 않도록 구현한다.
+- 함수(또는 메서드)가 한 가지 일만 하도록 최대한 작게 만들어라.
+- 배열 대신 컬렉션을 사용한다.
+- Java Enum을 적용한다.
+- 모든 원시 값과 문자열을 포장한다
+- 줄여 쓰지 않는다(축약 금지).
+- 일급 컬렉션을 쓴다.

src/main/java/Main.java

@@ -0,0 +1,9 @@
+import controller.Controller;
+import java.io.IOException;
+
+public class Main {
+    public static void main(String[] args) throws IOException {
+        Controller controller = new Controller();
+        controller.run();
+    }
+}

src/main/java/constant/MenuOption.java

@@ -0,0 +1,28 @@
+package constant;
+
+import java.util.Arrays;
+
+public enum MenuOption {
+    ATTENDANCE_REGISTER("1"),
+    ATTENDANCE_MODIFY("2"),
+    CREW_ATTENDANCE_CHECK("3"),
+    EXPULSION_RISK("4"),
+    QUIT("Q");
+
+    private final String inputMenuValue;
+
+    MenuOption(String inputMenuValue) {
+        this.inputMenuValue = inputMenuValue;
+    }
+
+    public static MenuOption validateSelectMenuOption(String input) {
+        return Arrays.stream(MenuOption.values())
+                .filter(option -> option.getInputMenuValue().equals(input))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("[ERROR] 유효하지 않은 선택입니다." + input));
+    }
+
+    public String getInputMenuValue() {
+        return inputMenuValue;
+    }
+}

src/main/java/controller/Controller.java

@@ -1,163 +1,134 @@
 package controller;
 
-import constant.DateFormatInformation;
+import constant.MenuOption;
 import java.io.IOException;
 import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
+import java.time.LocalTime;
 import java.util.List;
-import model.Student;
 import model.AttendanceBook;
-import util.FileInput;
-import util.LocalDateTimePrintFormatter;
+import model.Student;
+import util.AttendanceRecordFormatter;
+import util.FileInformationProvider;
 import view.InputView;
-import view.OutputView;
+import view.OutPutView;
 
 public class Controller {
-    private static final LocalDateTime TODAY = LocalDateTime.of(2024, 12, 13, 10, 0);
-    private static final int CHECK_IN = 1;
-    private static final int MODIFY_ATTENDANCE = 2;
-    private static final int CHECK_BY_CREW = 3;
-    private static final int CHECK_DROPOUT_RISK = 4;
-
-
-    private AttendanceBook readFileAndCreateStudentRepository() throws IOException {
-        FileInput fileInput = new FileInput();
-        List<Student> students = fileInput.createStudents();
-        return new AttendanceBook(students);
-    }
-
-    public AttendanceBook createStudentRepository() {
-        try {
-            return readFileAndCreateStudentRepository();
-        } catch (IOException e) {
-            return createStudentRepository();
-        }
-    }
-
-    public void attendanceStart() {
-        LocalDate todayDate = LocalDate.from(TODAY);
-        InputView.printTodayAndSelectFunction(todayDate);
-        AttendanceBook studentRepository = createStudentRepository();
-
-        for (Student student : studentRepository.getStudents()) {
-            student.getAttendanceRecords().updateStateNotExistInFile(todayDate);
-        }
+    private static final LocalDate TODAY = LocalDate.of(2024, 12, 13);
 
+    public void run() throws IOException {
+        AttendanceBook attendanceBook = new AttendanceBook(FileInformationProvider.loadStudentAttendance());
+        attendanceBook.updateNonExistentAttendanceRecords(TODAY);
         while (true) {
-            String selectFunction = InputView.getUserInputString();
-            if (selectFunction.equals("Q")) {
-                break;
-            }
-            if (Integer.parseInt(selectFunction) == CHECK_IN) {
-                functionForMenuOne(studentRepository, todayDate);
-            }
-            if (Integer.parseInt(selectFunction) == MODIFY_ATTENDANCE) {
-                functionForMenuTwo(studentRepository);
-            }
-            if (Integer.parseInt(selectFunction) == CHECK_BY_CREW) {
-                functionForMenuThree(studentRepository);
-            }
-            if (Integer.parseInt(selectFunction) == CHECK_DROPOUT_RISK) {
-                functionForMenuFour(studentRepository);
+            if (handleMenuChoice(attendanceBook)) {
+                return;
             }
         }
-
-    }
-
-    private static void functionForMenuFour(AttendanceBook studentRepository) {
-        OutputView.printEveryStudentPunishmentLabel(studentRepository);
-    }
-
-    private void functionForMenuThree(AttendanceBook studentRepository) {
-        String studentName = getStudentForAttendanceCheckUntilExist(studentRepository);
-        OutputView.printAttendanceRecord(studentRepository
-                .findStudentByName(studentName).getAttendanceRecords().getRecord());
-        studentRepository.findStudentByName(studentName).calculateAbsent();
-        OutputView.printStudentState(studentRepository.findStudentByName(studentName));
-        OutputView.printStudentPunishmentLabel(studentRepository.findStudentByName(studentName));
-    }
-
-    private void functionForMenuTwo(AttendanceBook studentRepository) {
-        String studentName = getStudentNameForModifyUntilValidate(studentRepository);
-        Student student = studentRepository.findStudentByName(studentName);
-        LocalDateTime modifyLocalDateTime = getLocalDateTimeToModify();
-        LocalDate modifyLocalDate = LocalDate.from(modifyLocalDateTime);
-        String recordBeforeModify = LocalDateTimePrintFormatter
-                .LocalDateTimeToLocalTime(modifyLocalDate,
-                        student.getAttendanceRecords().getRecord().get(modifyLocalDate)) +
-                student.findStateByLocalDateTime(modifyLocalDateTime);
-
-        student.modifyAttendanceRecord(modifyLocalDateTime);
-        String recordAfterModify = student.findStateByLocalDateTime(modifyLocalDateTime);
-
-        String localDateTimeFormat = modifyLocalDateTime.format(DateTimeFormatter.ofPattern(
-                DateFormatInformation.LOCAL_TIME_FORMATTER + " (" + recordAfterModify + ") 수정 완료!"));
-
-        OutputView.printSecondMenu(recordBeforeModify, localDateTimeFormat);
     }
 
-    private LocalDateTime getLocalDateTimeToModify() {
-        int modifyDate = InputView.inputDateForModify();
-        InputView.printTimeForModify();
-        LocalDate localDate = LocalDate.of(2024, 12, modifyDate);
-        return getTimeUntilValidate(localDate);
-    }
-
-    private void functionForMenuOne(AttendanceBook studentRepository, LocalDate todayDate) {
-        String studentName = getStudentForAttendanceCheckUntilExist(studentRepository);
-        LocalDateTime localDateTime = getLocalDateTimeUntilValidate(todayDate);
-        Student student = studentRepository.findStudentByName(studentName);
-        student.attendanceRegister(localDateTime);
-        OutputView.printTodayAttendanceResult(student, localDateTime);
+    private boolean handleMenuChoice(AttendanceBook attendanceBook) {
+        OutPutView.displayAttendanceMenu(TODAY);
+        MenuOption menuOption = chooseMenuOption();
+        if (menuOption.equals(MenuOption.ATTENDANCE_REGISTER)) {
+            registerAttendance(attendanceBook);
+        }
+        if (menuOption.equals(MenuOption.ATTENDANCE_MODIFY)) {
+            modifyAttendance(attendanceBook);
+        }
+        if (menuOption.equals(MenuOption.CREW_ATTENDANCE_CHECK)) {
+            checkCrewAttendance(attendanceBook);
+        }
+        if (menuOption.equals(MenuOption.EXPULSION_RISK)) {
+            checkExpulsionRisk(attendanceBook);
+        }
+        return menuOption.equals(MenuOption.QUIT);
     }
 
-    private String getStudentNameForModifyUntilValidate(AttendanceBook studentRepository) {
+    private MenuOption chooseMenuOption() {
         try {
-            InputView.printStudentNameForModify();
-            return getStudentNameUntilExist(studentRepository);
+            return InputView.inputChooseFunctionOption();
         } catch (IllegalArgumentException e) {
-            return getStudentNameForModifyUntilValidate(studentRepository);
+            System.out.println(e.getMessage());
+            return chooseMenuOption();
         }
     }
 
-    private LocalDateTime getLocalDateTimeUntilValidate(LocalDate todayDate) {
+    private void registerAttendance(AttendanceBook attendanceBook) {
         try {
-            InputView.printStartTime();
-            return getTimeUntilValidate(todayDate);
+            String nickName = requestNickName();
+            LocalTime attendanceTime = requestAttendanceTime();
+            Student student = attendanceBook.findStudentByNickName(nickName);
+            student.registerAttendanceRecord(TODAY, attendanceTime);
+            OutPutView.displayRegisterAttendanceRecord(AttendanceRecordFormatter.attendanceRecordFormatter(
+                    student, TODAY));
         } catch (IllegalArgumentException e) {
-            return getLocalDateTimeUntilValidate(todayDate);
+            System.out.println(e.getMessage());
+            registerAttendance(attendanceBook);
         }
     }
 
-    private String getStudentForAttendanceCheckUntilExist(AttendanceBook studentRepository) {
-        InputView.printInputNicName();
-        try {
-            return getStudentNameUntilExist(studentRepository);
-        } catch (IllegalArgumentException e) {
-            return getStudentForAttendanceCheckUntilExist(studentRepository);
-        }
+    private static LocalTime requestAttendanceTime() {
+        OutPutView.requestAttendanceTime();
+        return InputView.inputAttendanceTime();
     }
 
-    private String getStudentNameUntilExist(AttendanceBook studentRepository) {
-        String userName = InputView.userInput();
+    private void modifyAttendance(AttendanceBook attendanceBook) {
         try {
-            studentRepository.notExistStudent(userName);
-            return userName;
+            String nickName = requestModifyNickName();
+            int modifyDate = requestModifyDate();
+            Student student = attendanceBook.findStudentByNickName(nickName);
+            modifyAttendanceRecord(student, modifyDate);
         } catch (IllegalArgumentException e) {
             System.out.println(e.getMessage());
-            throw new IllegalArgumentException();
+            modifyAttendance(attendanceBook);
         }
     }
 
-    private LocalDateTime getTimeUntilValidate(LocalDate localDate) {
+    private void checkCrewAttendance(AttendanceBook attendanceBook) {
         try {
-            LocalDateTime localDateTimeToAttendanceCheck = InputView.makeLocalDateToLocalDateTime(localDate);
-            InputView.isNotOpeningHour(localDateTimeToAttendanceCheck);
-            return localDateTimeToAttendanceCheck;
+            String nickName = requestNickName();
+            Student student = attendanceBook.findStudentByNickName(nickName);
+            OutPutView.displayTotalAttendanceRecord(student);
+            OutPutView.displayTotalAttendanceCount(student);
+            OutPutView.displayCounselingCandidate(student);
         } catch (IllegalArgumentException e) {
             System.out.println(e.getMessage());
-            throw new IllegalArgumentException();
+            checkCrewAttendance(attendanceBook);
         }
     }
+
+    private void checkExpulsionRisk(AttendanceBook attendanceBook) {
+        List<Student> expulsionRiskStudents = attendanceBook.findExpulsionRiskStudents();
+        OutPutView.displayExpulsionRiskStudents(expulsionRiskStudents);
+    }
+
+    private void modifyAttendanceRecord(Student student, int modifyDate) {
+        LocalDate date = LocalDate.of(2024, 12, modifyDate);
+        String beforeRecord = AttendanceRecordFormatter.attendanceRecordFormatter(student, date);
+
+        LocalTime modifyTime = requestModifyTime();
+        student.modifyAttendanceRecord(modifyDate, modifyTime);
+
+        String afterRecord = AttendanceRecordFormatter.attendanceRecordFormatter(student, date);
+        OutPutView.displayModifyAttendanceRecord(beforeRecord, afterRecord);
+    }
+
+    private static String requestNickName() {
+        OutPutView.requestNickName();
+        return InputView.input();
+    }
+
+    private String requestModifyNickName() {
+        OutPutView.requestModifyNickName();
+        return InputView.input();
+    }
+
+    private int requestModifyDate() {
+        OutPutView.requestModifyDate();
+        return InputView.validateDateFormat(InputView.input());
+    }
+
+    private LocalTime requestModifyTime() {
+        OutPutView.requestModifyTime();
+        return InputView.validateTimeFormat(InputView.input());
+    }
 }