[지하철 노선도] 구현 완료

src/main/java/docs/README.md

@@ -0,0 +1,33 @@
+# 기능정의
+
+## 도메인
+
+### 지하철(Staion)
+
+- [x] 지하철역 등록 기능
+    - [x] [ERROR] 지하철역은 두글자 이상이여야 한다.
+    - [x] [ERROR] 지하철역은 한국어만 가능합니다.
+    - [x] [ERROR] 중복된 역 이름은 등록할 수 없습니다.
+- [x]  지하철역 삭제 기능
+    - [x] [ERROR] 존재하는 지하철역만 삭제 가능합니다.
+    - [x] [ERROR] 노선에 등록된 역은 삭제가 안됩니다.
+- [x]  지하철역 전체 조회 기능
+
+### 노선(Line)
+
+- [x]  노선 등록 기능
+    - [x] 등록시 상행 종점과 하행 종점을 입력받는다.
+    - [x] [ERROR] 노선의 이름은 두글자 이상이여야 한다.
+- [x]  노선 삭제 기능
+    - [x] [ERROR] 존재하는 노선만 삭제 가능합니다.
+- [x] 노선 목록 조회 기능
+- [x] 노선에 등록된 역 조회 기능
+    - [x] 노선의 상행 종점부터 하행 종점까지 순서대로 목록을 조회한다.
+
+### 구간
+
+- [x] 존재하는 노선에 역을 추가한다.
+    - [x] [ERROR] 등록된 역만 노선에 추가가 가능하다.
+- [x] 노선에 역을 삭제한다.
+    - [x] [ERROR] 노선에 역이 2개 이하면 삭제할 수 없다.
+    - [x] [ERROR] 노선에 존재하는 역만 삭제할 수 있다.

src/main/java/subway/Application.java

@@ -1,10 +1,10 @@
 package subway;
 
-import java.util.Scanner;
+import subway.common.AppConfig;
 
 public class Application {
     public static void main(String[] args) {
-        final Scanner scanner = new Scanner(System.in);
-        // TODO: 프로그램 구현
+
+        AppConfig.getInstance().subwayController().start();
     }
 }

src/main/java/subway/common/AppConfig.java

@@ -0,0 +1,51 @@
+package subway.common;
+
+import subway.controller.SubwayController;
+import subway.domain.LineRepository;
+import subway.domain.StationRepository;
+import subway.domain.Subway;
+import subway.service.SubwayService;
+import subway.view.InputView;
+import subway.view.OutputView;
+
+public class AppConfig {
+
+    private static AppConfig instance;
+
+    private AppConfig() {
+    }
+
+    public static AppConfig getInstance() {
+        if (instance == null) {
+            instance = new AppConfig();
+        }
+        return instance;
+    }
+
+    public SubwayController subwayController() {
+        return new SubwayController(outputView(), inputView(), subwayService());
+    }
+
+    private OutputView outputView() {
+        return new OutputView();
+    }
+    private InputView inputView() {
+        return new InputView();
+    }
+
+    private SubwayService subwayService() {
+        return new SubwayService(subway(), lineRepository(), stationRepository());
+    }
+
+    private Subway subway() {
+        return new Subway();
+    }
+
+    private LineRepository lineRepository() {
+        return new LineRepository();
+    }
+
+    private StationRepository stationRepository() {
+        return new StationRepository();
+    }
+}

src/main/java/subway/common/ExceptionHandler.java

@@ -0,0 +1,13 @@
+package subway.common;
+
+public class ExceptionHandler {
+
+    public static void retryOnException(final Runnable runnable) {
+        try {
+            runnable.run();
+        } catch (final IllegalArgumentException | IllegalStateException e) {
+            System.out.println(e.getMessage());
+            retryOnException(runnable);
+        }
+    }
+}

src/main/java/subway/constant/LineCommand.java

@@ -0,0 +1,25 @@
+package subway.constant;
+
+import java.util.Arrays;
+import subway.constant.message.ErrorMessage;
+
+public enum LineCommand {
+
+    SAVE("1"),
+    DELETE("2"),
+    SELECT("3"),
+    BACK("B");
+
+    private final String command;
+
+    LineCommand(final String command) {
+        this.command = command;
+    }
+
+    public static LineCommand from(final String input) {
+        return Arrays.stream(LineCommand.values())
+                     .filter(e -> e.command.equals(input))
+                     .findAny()
+                     .orElseThrow(() -> new IllegalArgumentException(ErrorMessage.ERROR_PREFIX.toMessage() + "없는 버튼입니다."));
+    }
+}

src/main/java/subway/constant/MainCommand.java

@@ -0,0 +1,25 @@
+package subway.constant;
+
+import java.util.Arrays;
+import subway.constant.message.ErrorMessage;
+
+public enum MainCommand {
+    STATION_MANAGE("1"),
+    LINE_MANAGE("2"),
+    SECTION_MANAGE("3"),
+    PRINT_SUBWAY("4"),
+    QUIT("Q");
+
+    private final String command;
+
+    MainCommand(final String command) {
+        this.command = command;
+    }
+
+    public static MainCommand from(final String input) {
+        return Arrays.stream(MainCommand.values())
+                     .filter(e -> e.command.equalsIgnoreCase(input))
+                     .findAny()
+                     .orElseThrow(() -> new IllegalArgumentException(ErrorMessage.ERROR_PREFIX.toMessage() + "없는 버튼입니다."));
+    }
+}

src/main/java/subway/constant/SectionCommand.java

@@ -0,0 +1,23 @@
+package subway.constant;
+
+import java.util.Arrays;
+import subway.constant.message.ErrorMessage;
+
+public enum SectionCommand {
+    SAVE("1"),
+    DELETE("2"),
+    BACK("B");
+
+    private final String command;
+
+    SectionCommand(final String command) {
+        this.command = command;
+    }
+
+    public static SectionCommand from(final String input) {
+        return Arrays.stream(SectionCommand.values())
+                     .filter(e -> e.command.equals(input))
+                     .findAny()
+                     .orElseThrow(() -> new IllegalArgumentException(ErrorMessage.ERROR_PREFIX.toMessage() + "없는 버튼입니다."));
+    }
+}

src/main/java/subway/constant/StationCommand.java

@@ -0,0 +1,24 @@
+package subway.constant;
+
+import java.util.Arrays;
+import subway.constant.message.ErrorMessage;
+
+public enum StationCommand {
+    SAVE("1"),
+    DELETE("2"),
+    SELECT("3"),
+    BACK("B");
+
+    private final String command;
+
+    StationCommand(final String command) {
+        this.command = command;
+    }
+
+    public static StationCommand from(final String input) {
+        return Arrays.stream(StationCommand.values())
+                     .filter(e -> e.command.equals(input))
+                     .findAny()
+                     .orElseThrow(() -> new IllegalArgumentException(ErrorMessage.ERROR_PREFIX.toMessage() + "없는 버튼입니다."));
+    }
+}

src/main/java/subway/constant/message/ErrorMessage.java

@@ -0,0 +1,15 @@
+package subway.constant.message;
+
+public enum ErrorMessage {
+    ERROR_PREFIX("[ERROR] ");
+
+    private final String message;
+
+    ErrorMessage(final String message) {
+        this.message = message;
+    }
+
+    public String toMessage() {
+        return message;
+    }
+}

src/main/java/subway/constant/message/Processmessage.java

@@ -0,0 +1,16 @@
+package subway.constant.message;
+
+public enum Processmessage {
+    SUCCESS_PREFIX("[INFO] "),
+    ;
+
+    private final String message;
+
+    Processmessage(final String message) {
+        this.message = message;
+    }
+
+    public String toMessage() {
+        return message;
+    }
+}

src/main/java/subway/controller/SubwayController.java

@@ -0,0 +1,127 @@
+package subway.controller;
+
+import java.util.List;
+import subway.common.ExceptionHandler;
+import subway.constant.LineCommand;
+import subway.constant.MainCommand;
+import subway.constant.SectionCommand;
+import subway.constant.StationCommand;
+import subway.domain.Subway;
+import subway.service.SubwayService;
+import subway.view.InputView;
+import subway.view.OutputView;
+
+public class SubwayController {
+
+    private final OutputView outputView;
+    private final InputView inputView;
+
+    public SubwayController(
+            final OutputView outputView,
+            final InputView inputView,
+            final SubwayService subwayService
+    ) {
+        this.outputView = outputView;
+        this.inputView = inputView;
+        this.subwayService = subwayService;
+    }
+
+    private final SubwayService subwayService;
+
+    public void start() {
+        subwayService.initializeSubway();
+        ExceptionHandler.retryOnException(this::startSubway);
+    }
+
+    private void startSubway() {
+        while (true) {
+            outputView.printMainView();
+            final String command = inputView.readCommand();
+            final MainCommand mainCommand = MainCommand.from(command);
+            if (mainCommand.equals(MainCommand.STATION_MANAGE)) {
+                manageStation();
+            }
+            if (mainCommand.equals(MainCommand.LINE_MANAGE)) {
+                manageLine();
+            }
+            if (mainCommand.equals(MainCommand.SECTION_MANAGE)) {
+                manageSection();
+            }
+            if (mainCommand.equals(MainCommand.PRINT_SUBWAY)) {
+                final Subway subway = subwayService.getSubway();
+                outputView.printSubway(subway);
+            }
+        }
+    }
+
+    private void manageSection() {
+        while (true) {
+            outputView.printSectionManageView();
+            final String sectionManageCommand = inputView.readCommand();
+            final SectionCommand sectionCommand = SectionCommand.from(sectionManageCommand);
+            if (sectionCommand.equals(SectionCommand.SAVE)) {
+                final String inputLine = inputView.readLineName();
+                final String inputStation = inputView.readStationName();
+                final String inputIndex = inputView.readStationInputIndex();
+                subwayService.addSubwayStation(inputLine, inputStation, inputIndex);
+            }
+            if (sectionCommand.equals(SectionCommand.DELETE)) {
+                final String inputLine = inputView.readDeleteLineName();
+                subwayService.deleteSubwayLine(inputLine);
+            }
+            if (sectionCommand.equals(SectionCommand.BACK)) {
+                break;
+            }
+        }
+    }
+
+    private void manageLine() {
+        while (true) {
+            outputView.printLineManageView();
+            final String lineManageCommand = inputView.readCommand();
+            final LineCommand lineCommand = LineCommand.from(lineManageCommand);
+            if (lineCommand.equals(LineCommand.SAVE)) {
+                final String inputName = inputView.readSaveLineName();
+                final String inputLineStartStationName = inputView.readLineStartStationName();
+                final String inputLineEndStationName = inputView.readLineEndStatationName();
+                subwayService.saveLine(inputName, inputLineStartStationName, inputLineEndStationName);
+                outputView.printSubwayAddSuccess();
+            }
+            if (lineCommand.equals(LineCommand.DELETE)) {
+                final String inputLineName = inputView.readDeleteLineName();
+                subwayService.deleteLine(inputLineName);
+                outputView.printSubwayDeleteSuccess();
+            }
+            if (lineCommand.equals(LineCommand.SELECT)) {
+                List<String> lineNames = subwayService.getAllLine();
+                outputView.printLines(lineNames);
+            }
+            if (lineCommand.equals(LineCommand.BACK)) {
+                break;
+            }
+        }
+    }
+
+    private void manageStation() {
+        while (true) {
+            outputView.printStationManageView();
+            final String stationManageCommand = inputView.readCommand();
+            final StationCommand stationCommand = StationCommand.from(stationManageCommand);
+            if (stationCommand.equals(StationCommand.SAVE)) {
+                final String input = inputView.readSaveStationName();
+                subwayService.saveStation(input);
+            }
+            if (stationCommand.equals(StationCommand.DELETE)) {
+                final String input = inputView.readDeleteStationName();
+                subwayService.deleteStation(input);
+            }
+            if (stationCommand.equals(StationCommand.SELECT)) {
+                final List<String> stationsName = subwayService.getAllStations();
+                outputView.printStations(stationsName);
+            }
+            if (stationCommand.equals(StationCommand.BACK)) {
+                break;
+            }
+        }
+    }
+}