[BE] 이동훈 👥 오늘의 짝꿍은?

docs/README.md

@@ -0,0 +1,75 @@
+# Leets 미션 1주차
+
+##  👥 미션 - 오늘의 짝꿍은?
+
+### ✅ 핵심 기능
+
+**목표**
+
+나의 짝꿍을 정해줄 랜덤 짝꿍 매칭 프로그램을 작성
+
+### ✅ 1주차 미션 목표
+
+#### 과제를 통해 생각해보기
+- 어떻게 하면 코드를 효율적으로 짤 수 있는지
+- 어떻게 하면 유지 보수가 쉬운 코드가 될 수 있는지
+- 객체지향 프로그래밍이 목표하는 바가 무엇이고 이를 어떻게 코드로 구현할 수 있는지
+
+### ✅ 구현할 기능 목록
+**[ Domain ]**
+-
+
+- [x]  **Member**
+
+- 참가자의 데이터 구조와 관련 로직을 담당
+- 문자열로된 멤버들을 리스트로 분리하고, 총 멤버수를 반환합니다.
+
+**[ Service ]**
+-
+
+- [x]  **GroupService**
+- 참가자들을 그룹화하는 로직을 담당
+- 랜덤 짝꿍을 추첨합니다.
+
+**[ View ]**
+-
+
+- [x]  **InputView**
+
+- 멤버 이름을 입력받음 (,로 구분)
+- 최대 짝 수를 입력받음
+- 다시 구성할지 말지 입력받음(y,n)
+
+- [x]  **OutputView**
+- 짝 추천 결과를 보여줌(default, y)
+- 인사 메세지를 보여줌(n)
+
+**[ Controller ]**
+-
+
+- [x]  **MatchingController**
+짝궁 추천 요청을 처리하는 로직을 구현
+
+### ✅ 예외 처리 - exception
+
+********공통********
+
+- [x]  예외 상황 시 에러 문구를 출력. 단, 에러 문구는 "[ERROR]"로 시작
+
+---
+
+**이름 입력**
+
+- [x] 이름이 한글이 아니면 예외처리
+
+---
+
+**최대 짝수 입력**
+
+- [x] 최대 짝 수가 이름의 갯수보다 크면 예외처리
+---
+
+**retry 입력**
+- [x] y와 n 이외의 숫자면 예외처리
+
+

src/main/java/leets/leets_mate/LeetsMateApplication.java

@@ -1,42 +1,10 @@
 package leets.leets_mate;
 
-import java.util.*;
+import leets.leets_mate.controller.MatchingController;
 
 public class LeetsMateApplication {
-
-    // 동작 함수입니다.
-    public void run() {
-    }
-
-    // 문자열로된 멤버들을 리스트로 분리하는 함수입니다.
-    public List<String> parseMembers(String members) {
-        return new ArrayList<>();
-    }
-
-    // 총 멤버수를 반환합니다.
-    public int memberNumber(List<String> members) {
-        return 0;
-    }
-
-    // 멤버 문자열에 영어가 있는지 검사합니다. 영어가 있다면 예외 출력
-    public void checkHasNoEnglish(String members) {
-    }
-
-    // 멤버수와 최대 짝수 데이터가 유효한지 검사하는 함수입니다. 유효하지 않다면 예외 출력
-    public void checkDataValidity(int memberCount, int maximumGroupSize) {
-    }
-
-    // 랜덤 짝꿍 추첨하는 함수 입니다.
-    public List<List<String>> generateRandomGroups(List<String> memberList, int maximumGroupSize) {
-        return new ArrayList<>();
-    }
-
-    // 결과를 프린트 하는 함수입니다.
-    public void printResult(List<List<String>> result) {
-    }
-
     public static void main(String[] args) {
-        LeetsMateApplication app = new LeetsMateApplication();
-        app.run();
+        MatchingController controller = new MatchingController();
+        controller.run();
     }
 }

src/main/java/leets/leets_mate/controller/MatchingController.java

@@ -0,0 +1,36 @@
+package leets.leets_mate.controller;
+
+import leets.leets_mate.domain.Member;
+import leets.leets_mate.service.GroupService;
+import leets.leets_mate.view.InputView;
+import leets.leets_mate.view.OutputView;
+
+import java.util.List;
+
+public class MatchingController {
+    GroupService groupService = new GroupService();
+
+    public void run() {
+        String[] members = InputView.readMember();
+        int maxGroupSize = InputView.readMaxGroup(members);
+
+        List<Member> membersOfList = Member.parseMembers(members);
+
+        boolean retry = true;
+        while (retry) {
+            List<List<Member>> groupsOfList = groupService.generateRandomGroups(membersOfList, maxGroupSize);
+
+            OutputView.printResult(groupsOfList);
+            OutputView.printCompletionMessage();
+
+            OutputView.printCanYouRetry();
+            retry = InputView.readRetry();
+
+            if (retry == true) {
+                OutputView.printLine();
+            }
+        }
+
+        OutputView.printDontWantRetry();
+    }
+}

src/main/java/leets/leets_mate/domain/Member.java

@@ -0,0 +1,29 @@
+package leets.leets_mate.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Member {
+    private String name;
+
+    public Member(String name) {
+        this.name = name;
+    }
+
+    public static List<Member> parseMembers(String[] memberName) {
+        List<Member> members = new ArrayList<>();
+        for (String name : memberName) {
+            members.add(new Member(name));
+        }
+
+        return members;
+    }
+
+    public static int memberNumber(List<Member> members) {
+        return members.size();
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/leets/leets_mate/service/GroupService.java

@@ -0,0 +1,32 @@
+package leets.leets_mate.service;
+
+import leets.leets_mate.domain.Member;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class GroupService {
+    public List<List<Member>> generateRandomGroups(List<Member> memberList, int maximumGroupSize) {
+        Collections.shuffle(memberList);
+
+        List<List<Member>> groups = new ArrayList<>();
+        List<Member> group = new ArrayList<>();
+
+        for (Member member : memberList) {
+            group.add(member);
+
+            if (group.size() == maximumGroupSize) {
+                groups.add(new ArrayList<>(group));
+                group.clear();
+            }
+        }
+
+        // 현재로써는 빈 그룹이 추가될 가능성이 보이지 않긴하나, 혹시 모를 빈 그룹 추가 방지
+        if (!group.isEmpty()) {
+            groups.add(group);
+        }
+
+        return groups;
+    }
+}

src/main/java/leets/leets_mate/view/InputView.java

@@ -0,0 +1,88 @@
+package leets.leets_mate.view;
+
+import leets.leets_mate.view.exception.IllegalArgumentExceptionType;
+
+import java.util.InputMismatchException;
+import java.util.Scanner;
+import java.util.regex.Pattern;
+
+public class InputView {
+    private static final Scanner kb = new Scanner(System.in);
+
+    private InputView() {
+    }
+
+    public static InputView create() {
+        return new InputView();
+    }
+
+    public static String[] readMember() {
+        OutputView.printStartMessage();
+        try {
+            String input = kb.nextLine();
+            String[] members = input.split(",");
+            for (String member : members) {
+                checkHasNoEnglish(member);
+            }
+            return members;
+        }
+        catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage()); // 추후 이부분은 enum으로 동아리 부원를 관리했을 때 없는 동아리 부원을 입력하면 에러메시지 출력도 하도록 구현
+            return readMember();
+        }
+    }
+
+    public static int readMaxGroup(String[] members) {
+        OutputView.printMaxGroup();
+        try {
+            int memberCount = members.length;
+            int maximumGroupSize = kb.nextInt();
+            kb.nextLine();
+
+            checkDataValidity(memberCount, maximumGroupSize);
+
+            System.out.println();
+            return maximumGroupSize;
+        } catch (InputMismatchException e) {
+            System.out.println(IllegalArgumentExceptionType.INVALID_MAX_GROUP.getMessage());
+            kb.nextLine();
+            return readMaxGroup((members));
+        } catch (IllegalArgumentException e){
+            System.out.println(e.getMessage());
+            return readMaxGroup(members);
+        }
+    }
+
+    public static void checkHasNoEnglish(String member) {
+        // Character.isAlphabetic()은 영어인지 구별해주는게 아닌 숫자와 문자를 구분해준다!
+//        for(char c : member.toCharArray()) {
+//            if (Character.isAlphabetic(c)) {
+//                throw IllegalArgumentExceptionType.INVALID_NAMING.getException();
+//            }
+//        }
+        if (Pattern.matches(".*[a-zA-Z]+.*", member)) {
+            throw IllegalArgumentExceptionType.INVALID_NAMING.getException();
+        }
+    }
+
+    public static void checkDataValidity(int memberCount, int maximumGroupSize) {
+        if (memberCount < maximumGroupSize) {
+            throw IllegalArgumentExceptionType.GROUP_SIZE_EXCEEDS_MEMBER_COUNT.getException();
+        }
+    }
+
+    public static boolean readRetry() {
+        try {
+            char c = kb.next().charAt(0);
+            if (c == 'y') {
+                return true;
+            } else if (c == 'n') {
+                return false;
+            } else
+                throw IllegalArgumentExceptionType.INVALID_RETRY_INPUT.getException();
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            return readRetry();
+        }
+    }
+}

src/main/java/leets/leets_mate/view/OutputView.java

@@ -0,0 +1,49 @@
+package leets.leets_mate.view;
+
+import leets.leets_mate.domain.Member;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class OutputView {
+    public static void printStartMessage() {
+        System.out.println("[Leets 오늘의 짝에게]를 시작합니다.");
+        System.out.println();
+        System.out.println("멤버의 이름을 입력해 주세요. (, 로 구분)");
+    }
+
+    public static void printMaxGroup() {
+        System.out.println();
+        System.out.println("최대 짝 수를 입력해 주세요.");
+    }
+
+    public static void printResult(List<List<Member>> result) {
+        System.out.println("오늘의 짝 추천 결과입니다.");
+        for (List<Member> group : result) {
+
+            List<String> memberNames = group.stream()
+                    .map(Member::getName)
+                    .collect(Collectors.toList());
+            String groupResult = String.join(" | ", memberNames);
+
+            System.out.println("[ " + groupResult + " ]");
+        }
+    }
+
+    public static void printCompletionMessage() {
+        System.out.println();
+        System.out.println("추천을 완료했습니다.");
+    }
+
+    public static void printCanYouRetry() {
+        System.out.print("다시 구성하시겠습니까? (y or n): ");
+    }
+
+    public static void printLine() {
+        System.out.println("--------------------------------");
+    }
+
+    public static void printDontWantRetry() {
+        System.out.println("자리를 이동해 서로에게 인사해주세요.");
+    }
+}

src/main/java/leets/leets_mate/view/exception/ExceptionType.java

@@ -0,0 +1,7 @@
+package leets.leets_mate.view.exception;
+
+public interface ExceptionType<T> {
+    String getMessage();
+
+    T getException();
+}

src/main/java/leets/leets_mate/view/exception/IllegalArgumentExceptionType.java

@@ -0,0 +1,25 @@
+package leets.leets_mate.view.exception;
+
+public enum IllegalArgumentExceptionType implements ExceptionType<IllegalArgumentException> {
+
+    INVALID_NAMING("[ERROR] 이름은 한글로 입력해야 합니다"),
+    GROUP_SIZE_EXCEEDS_MEMBER_COUNT("[ERROR] 최대 짝 수는 이름의 갯수보다 클 수 없습니다."),
+    INVALID_MAX_GROUP("[ERROR] 최대 짝수는 숫자로 입력해야 합니다"),
+    INVALID_RETRY_INPUT("[ERROR] y와 n만 입력이 가능합니다.");
+
+    private final String message;
+
+    IllegalArgumentExceptionType(String message) {
+        this.message = message;
+    }
+
+    @Override
+    public String getMessage() {
+        return message;
+    }
+
+    @Override
+    public IllegalArgumentException getException() {
+        return new IllegalArgumentException(getMessage());
+    }
+}