diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 000000000..b3729d76e --- /dev/null +++ b/docs/README.md @@ -0,0 +1,209 @@ +# 지하철 노선도 미션 +- 지하철 역과 노선을 관리하는 지하철 노선도 기능을 구현한다. + +## 구현 기능 목록 + +- [x] 프로그램 시작 시 역, 노선 등 필요한 정보를 미리 셋팅한다. +``` + 1. 지하철역으로 교대역, 강남역, 역삼역, 남부터미널역, 양재역, 양재시민의숲역, 매봉역이 등록되어 있다. + 2. 지하철 노선으로 2호선, 3호선, 신분당선이 등록되어 있다. + 3. 노선에 역이 아래와 같이 등록되어 있다.(왼쪽 끝이 상행 종점) + - 2호선: 교대역 - 강남역 - 역삼역 + - 3호선: 교대역 - 남부터미널역 - 양재역 - 매봉역 + - 신분당선: 강남역 - 양재역 - 양재시민의숲역 + ``` +- [x] 지하철 역을 생성 한다 + - 에외: 지하철 역 이름 입력 포멧이 ~역 이 아닌 경우 + - ~역이 아닌 입력을 허용하고 역을 붙이는 식으로 개발 시, 역이 역 이름의 역인지, station의 역인지 의미를가 불명확 하기 때문에 포멧 통일 + - 예외: 역 이름이 2자 이상이 아닌 경우 + +- [x] 지하철 역을 등록 한다 + - 예외: 지하철 역 이름이 중복인 경우 + +- [x] 지하철 역을 삭제 한다 + - 예외: 노선에 등록된 역을 삭제할 경우 + - 예외: 존재 하지 않는 역을 삭제할 경우 + +- [x] 지하철 역의 목록을 조회 한다 + - `[INFO]`를 붙여서 출력한다 + +- [x] 지하철 노선을 생성 한다 + - 구현: 상행 종점 역과 하행 종점 역을 입력 받아 노선을 생성 한다 + - 예외: 상행 종점과 하행 종점 역이 같은 경우 + - 예외: 노선 이름이 2자 이상이 아닌 경우 + - 예외: 상행역 및 하행역이 등록된 지하철 역이 아닐 경우 + - 에외: 지하철 노선 이름 입력 포멧이 ~선 이 아닌 경우 + +- [x] 지하철 노선을 등록 한다 + - 예외: 지하철 노선의 이름이 중복인 경우 + +- [x] 지하철 노선을 삭제 한다 + - 구현: 지하철 노선을 삭제한다 + - 예외: 존재하지 않는 노선 삭제 + +- [x] 지하철 노선의 목록을 조회 한다 + - `[INFO]`를 붙여서 출력한다 + +- [x] 지하철 노선에 역을 추가 한다 (구간 추가) + - 구현: 하나의 역은 여러개의 노선에 추가될 수 있다 + - 구현: 역과 역 사이에 새로운 역이 추가될 수 있다 + - 순서는 1부터 시작한다 + - 예외: 동일한 노선에 동일한 역이 추가 될 경우 + - 예외: 역 등록 위치 입력 시 숫자가 아닌 경우 + - 예외: 역 등록 위치 입력 시 구간 범위 를 벗어난 경우 + - 1 ~ 구간.size()-1 까지 + +- [x] 지하철 노선에 역을 삭제 한다 (구간 삭제) + - 구현: 종점을 제거할 경우 다음 역이 종점이 된다 + - 예외: 노선에 포함된 역이 2개 이하일 때 역을 제거하려 하는 경우 + +- [x] 지하철 노선에 등록된 역을 조회할 수 있다 + - 구현: 상행 종점부터 하행 종점까지 연결된 순서대로 역 목록을 조회한다 + +- [x] 에러 발생 시 `[ERROR]`를 붙여서 출력한다. + +- [x] 메인 화면을 출력한다 + - 구현: 메인화면은 다음과 같이 출력한다 + ``` + ## 메인 화면 + 1. 역 관리 + 2. 노선 관리 + 3. 구간 관리 + 4. 지하철 노선도 출력 + Q. 종료 + ``` + - 구현: 메인 화면이 나온 뒤 "원하는 기능을 선택하세요." 를 출력한다. + - [x] 구현: 지하철 노선도를 구현한다. + +- [x] 메인 화면 입력을 받는다. + - 구현: 사용자로 부터 기능을 선택 받는다. + - 구현: 올바른 입력인 경우, 해당 기능을 수행한다. + - 예외: 존재하지 않는 기능인 경우 + - `[ERROR]` 선택할 수 없는 기능입니다. + - "원하는 기능을 선택하세요." 재 출력 및 재 입력 + +- 공통사항 + - [x] 입력시 에러가 발생한 경우, 기능 선택이 잘못된 경우를 제외하고는 자신의 상위 화면으로 이동한다. + - [x] 기능 선택이 잘못된 경우는 기능 선택 메세지를 다시 출력하고 입력받는다. + - [x] 기능수행 완료 후 메인 화면으로 돌아온다 + +- [x] 역 관리 화면을 출력한다. + - 구현: 역 관리 화면은 다음과 같이 출력 한다 + ``` + ## 역 관리 화면 + 1. 역 등록 + 2. 역 삭제 + 3. 역 조회 + B. 돌아가기 + ``` + - 구현: 메인 화면이 나온 뒤 "원하는 기능을 선택하세요." 를 출력한다. + +- [x] 역 관리 화면 입력을 받는다. + - 구현: 사용자로 부터 기능을 선택 받는다. + + - 구현: 올바른 입력인 경우 아래와 같이 수행한다 + - 1. 역 등록 + - `## 등록할 역 이름을 입력하세요.` 출력 + - 에러시 에러 메시지 출력 + - 성공 시 `[INFO] 지하철 역이 등록되었습니다.` 출력 + - 2. 역 삭제 + - `## 삭제할 역 이름을 입력하세요.` 출력 + - 에러시 에러 메시지 출력 + - 성공할 경우 `[INFO] 지하철 역이 삭제되었습니다.` 출력 + + - 3. 역 조회 + - 역 조회시 아래와 같이 출력한다. + ``` + ## 역 목록 + $LIST + ``` + + - B. 돌아가기 + - 메인 화면으로 돌아간다 + + - 예외: 존재하지 않는 기능인 경우 + - `[ERROR] 선택할 수 없는 기능입니다.` 출력 + +- [ ] 노선 관리 화면을 출력한다 + - 구현: 역 관리 화면은 다음과 같이 출력 한다 + ``` + ## 역 관리 화면 + 1. 역 등록 + 2. 역 삭제 + 3. 역 조회 + B. 돌아가기 + ``` + - 구현: 메인 화면이 나온 뒤 "원하는 기능을 선택하세요." 를 출력한다. + +- [x] 노선 관리 화면 입력을 받는다. + - 구현: 사용자로 부터 기능을 선택 받는다. + + - 구현: 올바른 입력인 경우 아래와 같이 수행한다 + - 1. 노선 등록 + - `## 등록할 노선 이름을 입력하세요.` 출력 및 입력 + - 에러시 에러 메시지 출력 + - 성공 시 다음 진행 + - `## 등록할 노선의 상행 종점역 이름을 입력하세요.` 출력 및 입력 + - 에러시 에러 메시지 출력 + - 성공 시 다음 진행 + - `## 등록할 노선의 하행 종점역 이름을 입력하세요.` 출력 및 입력 + - 에러시 에러 메시지 출력 + - 성공 시 `[INFO] 지하철 노선이 등록되었습니다.` 출력 + - 2. 역 삭제 + - `## 삭제할 역 이름을 입력하세요.` 출력 + - 실패할 경우 `[ERROR] $ERROR_MESSAGE` 출력 + - 성공할 경우 `[INFO] 지하철 역이 삭제되었습니다.` 출력 + + - 3. 노선 조회 + - 노선 조회시 아래와 같이 출력한다. + ``` + ## 노선 목록 + $LIST + ``` + + - B. 돌아가기 + - 메인 화면으로 돌아간다 + + - 예외: 존재하지 않는 기능인 경우 + - `[ERROR] 선택할 수 없는 기능입니다.` 출력 + +- [x] 구간 관리 화면을 출력한다 + - 구현: 역 관리 화면은 다음과 같이 출력 한다 + ``` + ## 구간 관리 화면 + 1. 구간 등록 + 2. 구간 삭제 + B. 돌아가기 + ``` + - 구현: 메인 화면이 나온 뒤 "원하는 기능을 선택하세요." 를 출력한다. + +- [x] 노선 관리 화면 입력을 받는다. + - 구현: 사용자로 부터 기능을 선택 받는다. + + - 구현: 올바른 입력인 경우 아래와 같이 수행한다 + - 1. 구간 등록 + - `## 노선을 입력하세요.` 출력 및 입력 + - 에러시 에러 메시지 출력 + - 성공 시 다음 진행 + - `## 역이름을 입력하세요.` 출력 및 입력 + - 에러시 에러 메시지 출력 + - 성공 시 다음 진행 + - `## 순서를 입력하세요.` 출력 및 입력 + - 에러시 에러 메시지 출력 + - 성공 시 `[INFO] 지하철 노선이 등록되었습니다.` 출력 + - 2. 구간 삭제 + - `## 삭제할 구간의 노선을 입력하세요.` 출력 + - 에러시 에러 메시지 출력 + - 성공 시 다음 진행 + - `## 삭제할 구간의 역을 입력하세요.` 출력 + - 에러시 에러 메시지 출력 + - 성공 시 `[INFO] 구간이 삭제되었습니다.` 출력 + - B. 돌아가기 + - 메인 화면으로 돌아간다 + + - 예외: 존재하지 않는 기능인 경우 + - `[ERROR] 선택할 수 없는 기능입니다.` 출력 + +## 📝 License + +This project is [MIT](https://github.com/woowacourse/java-subway-map-precourse/blob/master/LICENSE.md) licensed. diff --git a/src/main/java/subway/Application.java b/src/main/java/subway/Application.java index 0bcf786cc..cc47ead98 100644 --- a/src/main/java/subway/Application.java +++ b/src/main/java/subway/Application.java @@ -1,10 +1,26 @@ package subway; -import java.util.Scanner; +import subway.controller.ControllerContainer; +import subway.controller.main.MainMenuController; +import subway.domain.line.Line; +import subway.domain.station.Station; +import subway.domain.station.StationName; +import subway.repository.line.LineRepository; +import subway.repository.line.LineRepositoryImpl; +import subway.repository.station.StationRepository; +import subway.repository.station.StationRepositoryImpl; +import subway.service.*; + +import java.util.Arrays; public class Application { + public static void main(String[] args) { - final Scanner scanner = new Scanner(System.in); - // TODO: 프로그램 구현 + LineRepository lineRepository = ControllerContainer.getLineRepository(); + StationRepository stationRepository = ControllerContainer.getStationRepository(); + + DummyData.init(); + + new MainMenuController(stationRepository, lineRepository).run(); } } diff --git a/src/main/java/subway/DummyData.java b/src/main/java/subway/DummyData.java new file mode 100644 index 000000000..7f3ce3f65 --- /dev/null +++ b/src/main/java/subway/DummyData.java @@ -0,0 +1,51 @@ +package subway; + +import subway.controller.ControllerContainer; +import subway.domain.line.Line; +import subway.domain.station.Station; +import subway.repository.line.LineRepository; +import subway.repository.station.StationRepository; +import subway.service.*; + +import java.util.Arrays; +import java.util.Objects; + +public class DummyData { + + private static StationRepository stationRepository = ControllerContainer.getStationRepository(); + private static LineRepository lineRepository = ControllerContainer.getLineRepository(); + + private static String[] stationNames = { + "교대역", "강남역", "역삼역", "남부터미널역", "양재역", "양재시민의숲역", "매봉역" + }; + + private static Station[] stations; + + private static Station from(String name) { + return Arrays.stream(stations) + .filter(station -> Objects.equals(station.getName().toString(), name)) + .findAny() + .orElse(null); + } + + public static void init() { + stations = Arrays.stream(stationNames) + .map(station -> new StationGenerateService().generate(station)) + .toArray(Station[]::new); + + Arrays.stream(stations).forEach(station -> new StationRegisterService(stationRepository).register(station)); + + Line line = new LineGenerateService(stationRepository).generate("2호선", from("교대역"), from("역삼역")); + new LineRegisterService(lineRepository).register(line); + new SectionRegisterService(stationRepository, lineRepository).add("2호선", "강남역", "1"); + + Line line3 = new LineGenerateService(stationRepository).generate("3호선", from("교대역"), from("매봉역")); + new LineRegisterService(lineRepository).register(line3); + new SectionRegisterService(stationRepository, lineRepository).add("3호선", "양재역", "1"); + new SectionRegisterService(stationRepository, lineRepository).add("3호선", "남부터미널역", "1"); + + Line shin = new LineGenerateService(stationRepository).generate("신분당선", from("강남역"), from("양재시민의숲역")); + new LineRegisterService(lineRepository).register(shin); + new SectionRegisterService(stationRepository, lineRepository).add("신분당선", "양재역", "1"); + } +} diff --git a/src/main/java/subway/controller/ControllerContainer.java b/src/main/java/subway/controller/ControllerContainer.java new file mode 100644 index 000000000..b83ec142d --- /dev/null +++ b/src/main/java/subway/controller/ControllerContainer.java @@ -0,0 +1,50 @@ +package subway.controller; + +import subway.controller.line.LineManagementController; +import subway.controller.main.MainMenuController; +import subway.controller.section.SectionManagementController; +import subway.controller.station.StationManagementController; +import subway.domain.station.Station; +import subway.repository.line.LineRepository; +import subway.repository.line.LineRepositoryImpl; +import subway.repository.station.StationRepository; +import subway.repository.station.StationRepositoryImpl; + +public class ControllerContainer { + + private static LineRepository lineRepository = new LineRepositoryImpl(); + private static StationRepository stationRepository = new StationRepositoryImpl(); + + private static MainMenuController mainMenuController = + new MainMenuController(stationRepository, lineRepository); + private static LineManagementController lineManagementController = + new LineManagementController(stationRepository, lineRepository); + private static StationManagementController stationManagementController = + new StationManagementController(stationRepository, lineRepository); + private static SectionManagementController sectionManagementController = + new SectionManagementController(stationRepository, lineRepository); + + public static MainMenuController getMainMenuController() { + return mainMenuController; + } + + public static LineManagementController getLineManagementController() { + return lineManagementController; + } + + public static StationManagementController getStationManagementController() { + return stationManagementController; + } + + public static SectionManagementController getSectionManagementController() { + return sectionManagementController; + } + + public static LineRepository getLineRepository() { + return lineRepository; + } + + public static StationRepository getStationRepository() { + return stationRepository; + } +} diff --git a/src/main/java/subway/controller/line/LineManagementController.java b/src/main/java/subway/controller/line/LineManagementController.java new file mode 100644 index 000000000..a70333114 --- /dev/null +++ b/src/main/java/subway/controller/line/LineManagementController.java @@ -0,0 +1,110 @@ +package subway.controller.line; + +import subway.domain.line.Line; +import subway.domain.line.LineName; +import subway.domain.station.Station; +import subway.domain.station.StationName; +import subway.exception.InvalidFunctionException; +import subway.exception.SubwayApplicationException; +import subway.exception.line.LineNameFormatException; +import subway.exception.line.LineNameLengthException; +import subway.exception.line.LineNotFoundException; +import subway.repository.line.LineRepository; +import subway.repository.station.StationRepository; +import subway.service.LineDeleteService; +import subway.service.LineGenerateService; +import subway.service.LineListService; +import subway.service.LineRegisterService; +import subway.view.inputView.InputView; +import subway.view.output.LineManagementView; +import subway.view.output.MainMenuView; +import subway.view.output.OutputView; + +import java.util.List; + +public class LineManagementController implements Runnable { + + private StationRepository stationRepository; + private LineRepository lineRepository; + + public LineManagementController(StationRepository stationRepository, LineRepository lineRepository) { + this.stationRepository = stationRepository; + this.lineRepository = lineRepository; + } + + @Override + public void run() { + try { + MainMenuView.printMenu(LineManagementMenu.toMenuString()); + Runnable function = selectFunction(); + if (function == null) { + return; + } + function.run(); + } catch (SubwayApplicationException e) { + run(); + } + } + + private Runnable selectFunction() { + LineManagementView.chooseFunction(); + String input = InputView.scan(); + + Runnable function; + try { + function = LineManagementMenu.find(input); + } catch (InvalidFunctionException e) { + OutputView.print(e.getMessage()); + return selectFunction(); + } + + return function; + } + + public void registerLine() { + Line line = generateLine(); + new LineRegisterService(lineRepository).register(line); + } + + private Line generateLine() { + LineManagementView.printRegisterMessage(); + String name = InputView.scan(); + + Station upline = getUpLineStation(); + Station downLine = getDownLineStation(); + + return new LineGenerateService(stationRepository).generate(name, upline, downLine); + } + + private Station getUpLineStation() { + LineManagementView.printUpLineNameInputMessage(); + + String upLineName = InputView.scan(); + StationName upLineStationName = StationName.of(upLineName); + + return Station.of(upLineStationName); + } + + private Station getDownLineStation() { + LineManagementView.printDownLineNameInputMessage(); + + String downLineName = InputView.scan(); + StationName downLineStationName = StationName.of(downLineName); + + return Station.of(downLineStationName); + } + + public void deleteLine() { + LineManagementView.printDeleteMessage(); + + String name = InputView.scan(); + LineName lineName = LineName.of(name); + + new LineDeleteService(lineRepository).delete(lineName); + } + + public void viewLine() { + List lines = new LineListService(lineRepository).get(); + LineManagementView.printLineList(lines); + } +} diff --git a/src/main/java/subway/controller/line/LineManagementMenu.java b/src/main/java/subway/controller/line/LineManagementMenu.java new file mode 100644 index 000000000..f793a4ee3 --- /dev/null +++ b/src/main/java/subway/controller/line/LineManagementMenu.java @@ -0,0 +1,59 @@ +package subway.controller.line; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; +import java.util.stream.Collectors; + +import subway.controller.ControllerContainer; +import subway.exception.InvalidFunctionException; + +public enum LineManagementMenu { + + LINE_REGISTER("1", "노선 등록", () -> { + ControllerContainer.getLineManagementController().registerLine(); + }), + LINE_DELETE("2", "노선 삭제", () -> { + ControllerContainer.getLineManagementController().deleteLine(); + }), + LINE_SCAN("3", "노선 조회", () -> { + ControllerContainer.getLineManagementController().viewLine(); + }), + BACK("B", "돌아가기", null), + ; + + private static final String HEADER = "\n## 노선 관리 화면"; + private final static String DELIMITER = ". "; + + String order; + String menuName; + Runnable function; + + LineManagementMenu(String order, String menuName, Runnable function) { + this.order = order; + this.menuName = menuName; + this.function = function; + } + + public static String toMenuString() { + List menuList = Arrays.stream(LineManagementMenu.values()) + .map(menu -> String.join(DELIMITER, String.valueOf(menu.order), menu.menuName)) + .collect(Collectors.toList()); + + List output = new ArrayList<>(); + output.add(HEADER); + output.addAll(menuList); + + return String.join(System.lineSeparator(), output); + } + + public static Runnable find(String input) { + return Arrays.stream(LineManagementMenu.values()) + .filter(menu -> Objects.equals(menu.order, input)) + .findAny() + .orElseThrow(() -> new InvalidFunctionException()) + .function; + } + +} diff --git a/src/main/java/subway/controller/main/MainMenu.java b/src/main/java/subway/controller/main/MainMenu.java new file mode 100644 index 000000000..52cf84c48 --- /dev/null +++ b/src/main/java/subway/controller/main/MainMenu.java @@ -0,0 +1,62 @@ +package subway.controller.main; + +import subway.controller.ControllerContainer; +import subway.exception.InvalidFunctionException; +import subway.view.output.OutputView; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; +import java.util.stream.Collectors; + +enum MainMenu { + + STATION_MANAGEMENT("1", "역 관리", () -> { + ControllerContainer.getStationManagementController().run(); + }), + LINE_MANAGEMENT("2", "노선 관리", () -> { + ControllerContainer.getLineManagementController().run(); + }), + SECTION_MANAGEMENT("3", "구간 관리", () -> { + ControllerContainer.getSectionManagementController().run(); + }), + PRINT_SUBWAY_MAP("4", "지하철 노선도 출력", () -> { + String routeMap = ControllerContainer.getMainMenuController().getRouteMap(); + OutputView.print(routeMap); + }), + EXIT("Q", "종료", null); + + private final static String HEADER = "\n## 메인 화면"; + private final static String DELIMITER = ". "; + + String order; + String menuName; + Runnable function; + + MainMenu(String order, String menuName, Runnable function) { + this.order = order; + this.menuName = menuName; + this.function = function; + } + + public static String toMenuString() { + List menuList = Arrays.stream(MainMenu.values()) + .map(menu -> String.join(DELIMITER, String.valueOf(menu.order), menu.menuName)) + .collect(Collectors.toList()); + + List output = new ArrayList<>(); + output.add(HEADER); + output.addAll(menuList); + + return String.join(System.lineSeparator(), output); + } + + public static Runnable find(String input) { + return Arrays.stream(MainMenu.values()) + .filter(menu -> Objects.equals(menu.order, input)) + .findAny() + .orElseThrow(() -> new InvalidFunctionException()) + .function; + } +} diff --git a/src/main/java/subway/controller/main/MainMenuController.java b/src/main/java/subway/controller/main/MainMenuController.java new file mode 100644 index 000000000..cd685a176 --- /dev/null +++ b/src/main/java/subway/controller/main/MainMenuController.java @@ -0,0 +1,55 @@ +package subway.controller.main; + +import subway.exception.InvalidFunctionException; +import subway.repository.line.LineRepository; +import subway.repository.station.StationRepository; +import subway.service.RouteMapService; +import subway.view.inputView.InputView; +import subway.view.output.MainMenuView; +import subway.view.output.OutputView; + +public class MainMenuController implements Runnable { + + private StationRepository stationRepository; + private LineRepository lineRepository; + + public MainMenuController(StationRepository stationRepository, LineRepository lineRepository) { + this.stationRepository = stationRepository; + this.lineRepository = lineRepository; + } + + @Override + public void run() { + while (true) { + MainMenuView.printMenu(MainMenu.toMenuString()); + Runnable function = selectFunction(); + if(function == null) { + break; + } + function.run(); + } + } + + private Runnable selectFunction() { + MainMenuView.chooseFunction(); + String input = InputView.scan(); + + Runnable function; + try { + function = MainMenu.find(input); + } catch (InvalidFunctionException e) { + OutputView.print(e.getMessage()); + return selectFunction(); + } + + return function; + } + + public String getRouteMap() { + return new RouteMapService(lineRepository).get(); + } + + public static void main(String[] args) { + new MainMenuController(null, null).run(); + } +} diff --git a/src/main/java/subway/controller/section/SectionManagementController.java b/src/main/java/subway/controller/section/SectionManagementController.java new file mode 100644 index 000000000..2883ac907 --- /dev/null +++ b/src/main/java/subway/controller/section/SectionManagementController.java @@ -0,0 +1,88 @@ +package subway.controller.section; + +import subway.domain.line.LineName; +import subway.domain.station.StationName; +import subway.exception.InvalidFunctionException; +import subway.exception.SubwayApplicationException; +import subway.repository.line.LineRepository; +import subway.repository.station.StationRepository; +import subway.service.SectionDeleteService; +import subway.service.SectionRegisterService; +import subway.service.StationGenerateService; +import subway.service.StationRegisterService; +import subway.view.inputView.InputView; +import subway.view.output.MainMenuView; +import subway.view.output.OutputView; +import subway.view.output.SectionManagementView; +import subway.view.output.StationManagementView; + +public class SectionManagementController implements Runnable { + + private StationRepository stationRepository; + private LineRepository lineRepository; + + public SectionManagementController(StationRepository stationRepository, LineRepository lineRepository) { + this.stationRepository = stationRepository; + this.lineRepository = lineRepository; + } + + @Override + public void run() { + try { + MainMenuView.printMenu(SectionManagementMenu.toMenuString()); + Runnable function = selectFunction(); + if (function == null) { + return; + } + function.run(); + } catch (SubwayApplicationException e) { + OutputView.print(e.getMessage()); + run(); + } + + } + + private Runnable selectFunction() { + MainMenuView.chooseFunction(); + String input = InputView.scan(); + + Runnable function; + try { + function = SectionManagementMenu.find(input); + } catch (InvalidFunctionException e) { + OutputView.print(e.getMessage()); + return selectFunction(); + } + + return function; + } + + public void registerSection() { + SectionManagementView.printLineInputMessage(); + String line = InputView.scan(); + + SectionManagementView.printStationNameInputMessage(); + String station = InputView.scan(); + + SectionManagementView.printPositionInputMessage(); + String position = InputView.scan(); + + new SectionRegisterService(stationRepository, lineRepository).add(line, station, position); + + SectionManagementView.printRegisterFinishMessage(); + } + + public void deleteSection() { + SectionManagementView.printDeleteLineInputMessage(); + String line = InputView.scan(); + LineName lineName = LineName.of(line); + + SectionManagementView.printDeleteStationInputMessage(); + String station = InputView.scan(); + StationName stationName = StationName.of(station); + + new SectionDeleteService(lineRepository).delete(lineName, stationName); + + SectionManagementView.printDeleteFinishMessage(); + } +} diff --git a/src/main/java/subway/controller/section/SectionManagementMenu.java b/src/main/java/subway/controller/section/SectionManagementMenu.java new file mode 100644 index 000000000..a5f7d5a12 --- /dev/null +++ b/src/main/java/subway/controller/section/SectionManagementMenu.java @@ -0,0 +1,56 @@ +package subway.controller.section; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; +import java.util.stream.Collectors; + +import subway.controller.ControllerContainer; +import subway.exception.InvalidFunctionException; + +public enum SectionManagementMenu { + + LINE_REGISTER("1", "구간 등록", () -> { + ControllerContainer.getSectionManagementController().registerSection(); + }), + LINE_DELETE("2", "구간 삭제", () -> { + ControllerContainer.getSectionManagementController().deleteSection(); + }), + BACK("B", "돌아가기", null), + ; + + private static final String HEADER = "\n## 구간 관리 화면"; + private final static String DELIMITER = ". "; + + String order; + String menuName; + Runnable function; + + SectionManagementMenu(String order, String menuName, Runnable function) { + this.order = order; + this.menuName = menuName; + this.function = function; + } + + public static String toMenuString() { + List menuList = Arrays.stream(SectionManagementMenu.values()) + .map(menu -> String.join(DELIMITER, String.valueOf(menu.order), menu.menuName)) + .collect(Collectors.toList()); + + List output = new ArrayList<>(); + output.add(HEADER); + output.addAll(menuList); + + return String.join(System.lineSeparator(), output); + } + + public static Runnable find(String input) { + return Arrays.stream(SectionManagementMenu.values()) + .filter(menu -> Objects.equals(menu.order, input)) + .findAny() + .orElseThrow(() -> new InvalidFunctionException()) + .function; + } + +} diff --git a/src/main/java/subway/controller/station/StationManagementController.java b/src/main/java/subway/controller/station/StationManagementController.java new file mode 100644 index 000000000..54a153426 --- /dev/null +++ b/src/main/java/subway/controller/station/StationManagementController.java @@ -0,0 +1,87 @@ +package subway.controller.station; + +import subway.domain.station.Station; +import subway.domain.station.StationName; +import subway.exception.InvalidFunctionException; +import subway.exception.SubwayApplicationException; +import subway.repository.line.LineRepository; +import subway.repository.station.StationRepository; +import subway.service.StationDeleteService; +import subway.service.StationGenerateService; +import subway.service.StationListService; +import subway.service.StationRegisterService; +import subway.view.inputView.InputView; +import subway.view.output.MainMenuView; +import subway.view.output.OutputView; +import subway.view.output.StationManagementView; + +import java.util.List; + +public class StationManagementController implements Runnable { + + private StationRepository stationRepository; + private LineRepository lineRepository; + + public StationManagementController(StationRepository stationRepository, LineRepository lineRepository) { + this.stationRepository = stationRepository; + this.lineRepository = lineRepository; + } + + @Override + public void run() { + try { + MainMenuView.printMenu(StationManagementMenu.toMenuString()); + Runnable function = selectFunction(); + + if (function == null) { + return; + } + + function.run(); + } catch (SubwayApplicationException e) { + run(); + } + } + + private Runnable selectFunction() { + MainMenuView.chooseFunction(); + String input = InputView.scan(); + + Runnable function; + try { + function = StationManagementMenu.find(input); + } catch (InvalidFunctionException e) { + OutputView.print(e.getMessage()); + return selectFunction(); + } + + return function; + } + + public void registerStation() { + StationManagementView.printRegisterMessage(); + + String name = InputView.scan(); + + Station station = new StationGenerateService().generate(name); + new StationRegisterService(stationRepository).register(station); + + StationManagementView.printRegisterFinishMessage(); + } + + public void deleteStation() { + StationManagementView.printDeleteMessage(); + + String name = InputView.scan(); + + StationName stationName = StationName.of(name); + new StationDeleteService(stationRepository, lineRepository).delete(stationName); + + StationManagementView.printDeleteFinishMessage(); + } + + public void viewStations() { + List stations = new StationListService(stationRepository).get(); + StationManagementView.printStationList(stations); + } +} diff --git a/src/main/java/subway/controller/station/StationManagementMenu.java b/src/main/java/subway/controller/station/StationManagementMenu.java new file mode 100644 index 000000000..e34b6a699 --- /dev/null +++ b/src/main/java/subway/controller/station/StationManagementMenu.java @@ -0,0 +1,60 @@ +package subway.controller.station; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; +import java.util.stream.Collectors; + +import subway.controller.ControllerContainer; +import subway.exception.InvalidFunctionException; + +public enum StationManagementMenu { + + + STATION_REGISTER("1", "역 등록", () -> { + ControllerContainer.getStationManagementController().registerStation(); + }), + STATION_DELETE("2", "역 삭제", () -> { + ControllerContainer.getStationManagementController().deleteStation(); + }), + STATION_SCAN("3", "역 조회", () -> { + ControllerContainer.getStationManagementController().viewStations(); + }), + BACK("B", "돌아가기", null), + ; + + private static final String HEADER = "\n## 역 관리 화면"; + private final static String DELIMITER = ". "; + + String order; + String menuName; + Runnable function; + + StationManagementMenu(String order, String menuName, Runnable function) { + this.order = order; + this.menuName = menuName; + this.function = function; + } + + public static String toMenuString() { + List menuList = Arrays.stream(StationManagementMenu.values()) + .map(menu -> String.join(DELIMITER, String.valueOf(menu.order), menu.menuName)) + .collect(Collectors.toList()); + + List output = new ArrayList<>(); + output.add(HEADER); + output.addAll(menuList); + + return String.join(System.lineSeparator(), output); + } + + public static Runnable find(String input) { + return Arrays.stream(StationManagementMenu.values()) + .filter(menu -> Objects.equals(menu.order, input)) + .findAny() + .orElseThrow(() -> new InvalidFunctionException()) + .function; + } + +} diff --git a/src/main/java/subway/domain/Line.java b/src/main/java/subway/domain/Line.java deleted file mode 100644 index f4d738d5a..000000000 --- a/src/main/java/subway/domain/Line.java +++ /dev/null @@ -1,15 +0,0 @@ -package subway.domain; - -public class Line { - private String name; - - public Line(String name) { - this.name = name; - } - - public String getName() { - return name; - } - - // 추가 기능 구현 -} diff --git a/src/main/java/subway/domain/LineRepository.java b/src/main/java/subway/domain/LineRepository.java deleted file mode 100644 index 49132ddb6..000000000 --- a/src/main/java/subway/domain/LineRepository.java +++ /dev/null @@ -1,22 +0,0 @@ -package subway.domain; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Objects; - -public class LineRepository { - private static final List lines = new ArrayList<>(); - - public static List lines() { - return Collections.unmodifiableList(lines); - } - - public static void addLine(Line line) { - lines.add(line); - } - - public static boolean deleteLineByName(String name) { - return lines.removeIf(line -> Objects.equals(line.getName(), name)); - } -} diff --git a/src/main/java/subway/domain/Station.java b/src/main/java/subway/domain/Station.java deleted file mode 100644 index bdb142590..000000000 --- a/src/main/java/subway/domain/Station.java +++ /dev/null @@ -1,15 +0,0 @@ -package subway.domain; - -public class Station { - private String name; - - public Station(String name) { - this.name = name; - } - - public String getName() { - return name; - } - - // 추가 기능 구현 -} diff --git a/src/main/java/subway/domain/StationRepository.java b/src/main/java/subway/domain/StationRepository.java deleted file mode 100644 index b7245c0f3..000000000 --- a/src/main/java/subway/domain/StationRepository.java +++ /dev/null @@ -1,22 +0,0 @@ -package subway.domain; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Objects; - -public class StationRepository { - private static final List stations = new ArrayList<>(); - - public static List stations() { - return Collections.unmodifiableList(stations); - } - - public static void addStation(Station station) { - stations.add(station); - } - - public static boolean deleteStation(String name) { - return stations.removeIf(station -> Objects.equals(station.getName(), name)); - } -} diff --git a/src/main/java/subway/domain/line/Line.java b/src/main/java/subway/domain/line/Line.java new file mode 100644 index 000000000..9ef082c67 --- /dev/null +++ b/src/main/java/subway/domain/line/Line.java @@ -0,0 +1,65 @@ +package subway.domain.line; + +import subway.domain.station.Station; +import subway.domain.station.StationName; +import subway.exception.line.SectionSizeLowException; + +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; +import java.util.Objects; + +public class Line { + private static final int MINIMUM_SECTIONS_LENGTH = 2; + private static final int MINIMUM_POSITION_RANGE = 1; + + private LineName name; + private List sections; + + private Line(LineName name, Station upLine, Station downLine) { + List sections = createSectionsWithUpLineAndDownLine(upLine, downLine); + this.name = name; + this.sections = sections; + } + + public static Line fromNameAndUpLineAndDownLine(LineName name, Station upLine, Station downLine) { + return new Line(name, upLine, downLine); + } + + private static List createSectionsWithUpLineAndDownLine(Station upLine, Station downLine) { + List sections = new LinkedList<>(); + sections.add(upLine); + sections.add(downLine); + + return sections; + } + + public List sections() { + return Collections.unmodifiableList(sections); + } + + public boolean isRightPosition(int position) { + return MINIMUM_POSITION_RANGE <= position && position < sections.size(); + } + + public void add(int position, Station station) { + sections.add(position, station); + } + + public boolean deleteStationByName(StationName stationName) { + if (sections.size() == MINIMUM_SECTIONS_LENGTH) { + throw new SectionSizeLowException(); + } + + return sections.removeIf(station -> Objects.equals(station.getName(), name)); + } + + public LineName getName() { + return name; + } + + public boolean contains(StationName name) { + return sections.stream() + .anyMatch(station -> Objects.equals(name, station.getName())); + } +} diff --git a/src/main/java/subway/domain/line/LineName.java b/src/main/java/subway/domain/line/LineName.java new file mode 100644 index 000000000..f4ee3c9a9 --- /dev/null +++ b/src/main/java/subway/domain/line/LineName.java @@ -0,0 +1,60 @@ +package subway.domain.line; + +import subway.domain.station.StationName; +import subway.exception.SubwayApplicationException; +import subway.exception.line.LineNameFormatException; +import subway.exception.line.LineNameLengthException; + +import java.util.Objects; + +public class LineName { + private static final int MINIMUM_LINE_NAME_SIZE = 2; + private static final String LINE_IN_KOREAN = "선"; + + private String name; + + private LineName(String name) { + try { + validateName(name); + } catch (LineNameFormatException | LineNameLengthException e) { + throw new SubwayApplicationException(e); + } + + this.name = name; + } + + public static LineName of(String name) { + return new LineName(name); + } + + private void validateName(String name) { + validateEndWithLine(name); + validateLength(name); + } + + private void validateEndWithLine(String name) { + if (!name.endsWith(LINE_IN_KOREAN)) { + throw new LineNameFormatException(); + } + } + + private void validateLength(String name) { + if (!(name.length() - LINE_IN_KOREAN.length() >= MINIMUM_LINE_NAME_SIZE)) { + throw new LineNameLengthException(); + } + } + + @Override + public boolean equals(Object o) { + if (o instanceof LineName) { + return Objects.equals(name, ((LineName) o).name); + } + + return false; + } + + @Override + public String toString() { + return name; + } +} diff --git a/src/main/java/subway/domain/station/Station.java b/src/main/java/subway/domain/station/Station.java new file mode 100644 index 000000000..7bc094835 --- /dev/null +++ b/src/main/java/subway/domain/station/Station.java @@ -0,0 +1,28 @@ +package subway.domain.station; + +import java.util.Objects; + +public class Station { + private StationName name; + + private Station(StationName name) { + this.name = name; + } + + public static Station of(StationName name) { + return new Station(name); + } + + public StationName getName() { + return name; + } + + @Override + public boolean equals(Object o) { + if(o instanceof Station) { + return Objects.equals(((Station) o).name, this.name); + } + + return false; + } +} diff --git a/src/main/java/subway/domain/station/StationName.java b/src/main/java/subway/domain/station/StationName.java new file mode 100644 index 000000000..ff016af9f --- /dev/null +++ b/src/main/java/subway/domain/station/StationName.java @@ -0,0 +1,59 @@ +package subway.domain.station; + +import subway.exception.SubwayApplicationException; +import subway.exception.station.StationNameFormatException; +import subway.exception.station.StationNameLengthException; + +import java.util.Objects; + +public class StationName { + private static final int MINIMUM_STATION_NAME_SIZE = 2; + private static final String STATION_IN_KOREAN = "역"; + + private String name; + + private StationName(String name) { + try { + validateName(name); + } catch (StationNameFormatException | StationNameLengthException e) { + throw new SubwayApplicationException(e); + } + + this.name = name; + } + + public static StationName of(String name) { + return new StationName(name); + } + + private void validateName(String name) { + validateEndWithStation(name); + validateLength(name); + } + + private void validateEndWithStation(String name) { + if (!name.endsWith(STATION_IN_KOREAN)) { + throw new StationNameFormatException(); + } + } + + private void validateLength(String name) { + if (!(name.length() - STATION_IN_KOREAN.length() >= MINIMUM_STATION_NAME_SIZE)) { + throw new StationNameLengthException(); + } + } + + @Override + public String toString() { + return name; + } + + @Override + public boolean equals(Object o) { + if (o instanceof StationName) { + return Objects.equals(name, ((StationName) o).name); + } + + return false; + } +} diff --git a/src/main/java/subway/exception/InvalidFunctionException.java b/src/main/java/subway/exception/InvalidFunctionException.java new file mode 100644 index 000000000..65c03cddd --- /dev/null +++ b/src/main/java/subway/exception/InvalidFunctionException.java @@ -0,0 +1,11 @@ +package subway.exception; + +import subway.view.util.Formatter; + +public class InvalidFunctionException extends RuntimeException { + private static final String MESSAGE = Formatter.Error("선택할 수 없는 기능입니다."); + + public InvalidFunctionException() { + super(MESSAGE); + } +} diff --git a/src/main/java/subway/exception/SubwayApplicationException.java b/src/main/java/subway/exception/SubwayApplicationException.java new file mode 100644 index 000000000..e114da429 --- /dev/null +++ b/src/main/java/subway/exception/SubwayApplicationException.java @@ -0,0 +1,7 @@ +package subway.exception; + +public class SubwayApplicationException extends RuntimeException { + public SubwayApplicationException(RuntimeException e) { + super(e); + } +} diff --git a/src/main/java/subway/exception/line/LineAlreadyExistException.java b/src/main/java/subway/exception/line/LineAlreadyExistException.java new file mode 100644 index 000000000..d52592769 --- /dev/null +++ b/src/main/java/subway/exception/line/LineAlreadyExistException.java @@ -0,0 +1,11 @@ +package subway.exception.line; + +import subway.view.util.Formatter; + +public class LineAlreadyExistException extends RuntimeException { + private static final String MESSAGE = Formatter.Error("노선이 이미 존재합니다."); + + public LineAlreadyExistException() { + super(MESSAGE); + } +} diff --git a/src/main/java/subway/exception/line/LineNameFormatException.java b/src/main/java/subway/exception/line/LineNameFormatException.java new file mode 100644 index 000000000..963b7ba11 --- /dev/null +++ b/src/main/java/subway/exception/line/LineNameFormatException.java @@ -0,0 +1,11 @@ +package subway.exception.line; + +import subway.view.util.Formatter; + +public class LineNameFormatException extends RuntimeException { + private static final String MESSAGE = Formatter.Error("이름 포멧이 이상합니다."); + + public LineNameFormatException() { + super(MESSAGE); + } +} diff --git a/src/main/java/subway/exception/line/LineNameLengthException.java b/src/main/java/subway/exception/line/LineNameLengthException.java new file mode 100644 index 000000000..2ccc00993 --- /dev/null +++ b/src/main/java/subway/exception/line/LineNameLengthException.java @@ -0,0 +1,11 @@ +package subway.exception.line; + +import subway.view.util.Formatter; + +public class LineNameLengthException extends RuntimeException { + private static final String MESSAGE = Formatter.Error("노선이 이름의 길이는 2자 이상입니다."); + + public LineNameLengthException() { + super(MESSAGE); + } +} \ No newline at end of file diff --git a/src/main/java/subway/exception/line/LineNotFoundException.java b/src/main/java/subway/exception/line/LineNotFoundException.java new file mode 100644 index 000000000..7989d0dee --- /dev/null +++ b/src/main/java/subway/exception/line/LineNotFoundException.java @@ -0,0 +1,11 @@ +package subway.exception.line; + +import subway.view.util.Formatter; + +public class LineNotFoundException extends RuntimeException { + private static final String MESSAGE = Formatter.Error("노선을 찾을 수 없습니다."); + + public LineNotFoundException() { + super(MESSAGE); + } +} diff --git a/src/main/java/subway/exception/line/PositionRangeException.java b/src/main/java/subway/exception/line/PositionRangeException.java new file mode 100644 index 000000000..f43579e4b --- /dev/null +++ b/src/main/java/subway/exception/line/PositionRangeException.java @@ -0,0 +1,11 @@ +package subway.exception.line; + +import subway.view.util.Formatter; + +public class PositionRangeException extends RuntimeException { + private static final String MESSAGE = Formatter.Error("위치 입력 범위가 비정상입니다."); + + public PositionRangeException() { + super(MESSAGE); + } +} diff --git a/src/main/java/subway/exception/line/SectionSizeLowException.java b/src/main/java/subway/exception/line/SectionSizeLowException.java new file mode 100644 index 000000000..8cf9e5c56 --- /dev/null +++ b/src/main/java/subway/exception/line/SectionSizeLowException.java @@ -0,0 +1,11 @@ +package subway.exception.line; + +import subway.view.util.Formatter; + +public class SectionSizeLowException extends RuntimeException { + private static final String MESSAGE = Formatter.Error("구간의 크기는 2보다 작을 수 없습니다."); + + public SectionSizeLowException() { + super(MESSAGE); + } +} diff --git a/src/main/java/subway/exception/station/SameUpLineAndDownLineException.java b/src/main/java/subway/exception/station/SameUpLineAndDownLineException.java new file mode 100644 index 000000000..d26da5a92 --- /dev/null +++ b/src/main/java/subway/exception/station/SameUpLineAndDownLineException.java @@ -0,0 +1,11 @@ +package subway.exception.station; + +import subway.view.util.Formatter; + +public class SameUpLineAndDownLineException extends RuntimeException { + private static final String MESSAGE = Formatter.Error("하행선과 상행선이 동일합니다."); + + public SameUpLineAndDownLineException() { + super(MESSAGE); + } +} diff --git a/src/main/java/subway/exception/station/StationAlreadyExistException.java b/src/main/java/subway/exception/station/StationAlreadyExistException.java new file mode 100644 index 000000000..47a1e56e2 --- /dev/null +++ b/src/main/java/subway/exception/station/StationAlreadyExistException.java @@ -0,0 +1,11 @@ +package subway.exception.station; + +import subway.view.util.Formatter; + +public class StationAlreadyExistException extends RuntimeException { + private static final String MESSAGE = Formatter.Error("역이 이미 존재합니다."); + + public StationAlreadyExistException() { + super(MESSAGE); + } +} diff --git a/src/main/java/subway/exception/station/StationNameFormatException.java b/src/main/java/subway/exception/station/StationNameFormatException.java new file mode 100644 index 000000000..ca4623e80 --- /dev/null +++ b/src/main/java/subway/exception/station/StationNameFormatException.java @@ -0,0 +1,11 @@ +package subway.exception.station; + +import subway.view.util.Formatter; + +public class StationNameFormatException extends RuntimeException { + private static final String MESSAGE = Formatter.Error("역 이름 혁식이 맞지 않습니다."); + + public StationNameFormatException() { + super(MESSAGE); + } +} diff --git a/src/main/java/subway/exception/station/StationNameLengthException.java b/src/main/java/subway/exception/station/StationNameLengthException.java new file mode 100644 index 000000000..9bdc1c63a --- /dev/null +++ b/src/main/java/subway/exception/station/StationNameLengthException.java @@ -0,0 +1,11 @@ +package subway.exception.station; + +import subway.view.util.Formatter; + +public class StationNameLengthException extends RuntimeException { + private static final String MESSAGE = Formatter.Error("역 이름 길이가 너무 짧습니다."); + + public StationNameLengthException() { + super(MESSAGE); + } +} diff --git a/src/main/java/subway/exception/station/StationNotFoundException.java b/src/main/java/subway/exception/station/StationNotFoundException.java new file mode 100644 index 000000000..c9b2c02d7 --- /dev/null +++ b/src/main/java/subway/exception/station/StationNotFoundException.java @@ -0,0 +1,11 @@ +package subway.exception.station; + +import subway.view.util.Formatter; + +public class StationNotFoundException extends RuntimeException { + private static final String MESSAGE = Formatter.Error("역을 찾을 수 없습니다."); + + public StationNotFoundException() { + super(MESSAGE); + } +} diff --git a/src/main/java/subway/exception/station/StationRegisteredOnLineException.java b/src/main/java/subway/exception/station/StationRegisteredOnLineException.java new file mode 100644 index 000000000..595fd5e6a --- /dev/null +++ b/src/main/java/subway/exception/station/StationRegisteredOnLineException.java @@ -0,0 +1,11 @@ +package subway.exception.station; + +import subway.view.util.Formatter; + +public class StationRegisteredOnLineException extends RuntimeException { + private static final String MESSAGE = Formatter.Error("역이 노선에 존재합니다."); + + public StationRegisteredOnLineException() { + super(MESSAGE); + } +} diff --git a/src/main/java/subway/repository/line/LineRepository.java b/src/main/java/subway/repository/line/LineRepository.java new file mode 100644 index 000000000..1407b8ad9 --- /dev/null +++ b/src/main/java/subway/repository/line/LineRepository.java @@ -0,0 +1,13 @@ +package subway.repository.line; + +import subway.domain.line.Line; +import subway.domain.line.LineName; + +import java.util.List; + +public interface LineRepository { + List lines(); + void addLine(Line line); + boolean deleteLineByName(LineName name); + Line findLineByName(LineName name); +} diff --git a/src/main/java/subway/repository/line/LineRepositoryImpl.java b/src/main/java/subway/repository/line/LineRepositoryImpl.java new file mode 100644 index 000000000..0da82f9a5 --- /dev/null +++ b/src/main/java/subway/repository/line/LineRepositoryImpl.java @@ -0,0 +1,37 @@ +package subway.repository.line; + +import subway.domain.line.Line; +import subway.domain.line.LineName; +import subway.exception.line.LineNotFoundException; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Objects; + +public class LineRepositoryImpl implements LineRepository { + private final List lines = new ArrayList<>(); + + @Override + public List lines() { + return Collections.unmodifiableList(lines); + } + + @Override + public void addLine(Line line) { + lines.add(line); + } + + @Override + public boolean deleteLineByName(LineName name) { + return lines.removeIf(line -> Objects.equals(line.getName(), name)); + } + + @Override + public Line findLineByName(LineName name) { + return lines.stream() + .filter(line -> Objects.equals(line.getName(), name)) + .findAny() + .orElseThrow(() -> new LineNotFoundException()); + } +} diff --git a/src/main/java/subway/repository/station/StationRepository.java b/src/main/java/subway/repository/station/StationRepository.java new file mode 100644 index 000000000..0e6321e95 --- /dev/null +++ b/src/main/java/subway/repository/station/StationRepository.java @@ -0,0 +1,13 @@ +package subway.repository.station; + +import subway.domain.station.Station; +import subway.domain.station.StationName; + +import java.util.List; + +public interface StationRepository { + List stations(); + void addStation(Station station); + boolean deleteStation(StationName name); + Station getStationByName(StationName name); +} diff --git a/src/main/java/subway/repository/station/StationRepositoryImpl.java b/src/main/java/subway/repository/station/StationRepositoryImpl.java new file mode 100644 index 000000000..71c5cc65d --- /dev/null +++ b/src/main/java/subway/repository/station/StationRepositoryImpl.java @@ -0,0 +1,40 @@ +package subway.repository.station; + +import subway.domain.station.Station; +import subway.domain.station.StationName; +import subway.exception.station.StationNotFoundException; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Objects; + +public class StationRepositoryImpl implements StationRepository { + private final List stations = new ArrayList<>(); + + @Override + public List stations() { + return Collections.unmodifiableList(stations); + } + + public void addStation(Station station) { + stations.add(station); + } + + + + @Override + public boolean deleteStation(StationName name) { + return stations.removeIf(station -> Objects.equals(station.getName(), name)); + } + + @Override + public Station getStationByName(StationName name) { + Station goalStation = stations.stream() + .filter(station -> Objects.equals(station.getName(), name)) + .findAny() + .orElseThrow(() -> new StationNotFoundException()); + + return goalStation; + } +} diff --git a/src/main/java/subway/service/LineDeleteService.java b/src/main/java/subway/service/LineDeleteService.java new file mode 100644 index 000000000..a011aae7a --- /dev/null +++ b/src/main/java/subway/service/LineDeleteService.java @@ -0,0 +1,29 @@ +package subway.service; + +import subway.domain.line.LineName; +import subway.exception.SubwayApplicationException; +import subway.exception.line.LineNotFoundException; +import subway.repository.line.LineRepository; + +public class LineDeleteService { + private final LineRepository lineRepository; + + public LineDeleteService(LineRepository lineRepository) { + this.lineRepository = lineRepository; + } + + public void delete(LineName name) { + try { + deleteLine(name); + } catch (LineNotFoundException e) { + throw new SubwayApplicationException(e); + } + } + + private void deleteLine(LineName name) { + boolean success = lineRepository.deleteLineByName(name); + if (!success) { + throw new LineNotFoundException(); + } + } +} diff --git a/src/main/java/subway/service/LineGenerateService.java b/src/main/java/subway/service/LineGenerateService.java new file mode 100644 index 000000000..7bd5b0d97 --- /dev/null +++ b/src/main/java/subway/service/LineGenerateService.java @@ -0,0 +1,55 @@ +package subway.service; + +import subway.domain.line.LineName; +import subway.domain.station.Station; +import subway.exception.line.LineNameFormatException; +import subway.exception.line.LineNameLengthException; +import subway.exception.station.SameUpLineAndDownLineException; +import subway.exception.station.StationNotFoundException; +import subway.exception.SubwayApplicationException; +import subway.repository.station.StationRepository; +import subway.specification.StationAlreadyRegisteredSpecification; +import subway.specification.SameUpLineAndDownLineSpecification; +import subway.domain.line.Line; + +public class LineGenerateService { + private final StationRepository stationRepository; + + public LineGenerateService(StationRepository stationRepository) { + this.stationRepository = stationRepository; + } + + public Line generate(String name, Station upLine, Station downLine) { + LineName lineName; + try { + validateSameUpLineAndDownLine(upLine, downLine); + validateIsRegisteredStation(upLine); + validateIsRegisteredStation(downLine); + + lineName = LineName.of(name); + } catch (SameUpLineAndDownLineException | StationNotFoundException | + LineNameFormatException | LineNameLengthException e) { + throw new SubwayApplicationException(e); + } + + return Line.fromNameAndUpLineAndDownLine(lineName, upLine, downLine); + } + + private void validateSameUpLineAndDownLine(Station upLine, Station DownLine) { + SameUpLineAndDownLineSpecification sameUpLineAndDownLineSpecification = + new SameUpLineAndDownLineSpecification(); + + if (sameUpLineAndDownLineSpecification.isSatisfiedBy(upLine, DownLine)) { + throw new SameUpLineAndDownLineException(); + } + } + + private void validateIsRegisteredStation(Station station) { + StationAlreadyRegisteredSpecification stationAlreadyRegisteredSpecification = + new StationAlreadyRegisteredSpecification(stationRepository); + + if (!stationAlreadyRegisteredSpecification.isSatisfiedBy(station)) { + throw new StationNotFoundException(); + } + } +} diff --git a/src/main/java/subway/service/LineListService.java b/src/main/java/subway/service/LineListService.java new file mode 100644 index 000000000..81ff3d6dc --- /dev/null +++ b/src/main/java/subway/service/LineListService.java @@ -0,0 +1,18 @@ +package subway.service; + +import subway.domain.line.Line; +import subway.repository.line.LineRepository; + +import java.util.List; + +public class LineListService { + private final LineRepository lineRepository; + + public LineListService(LineRepository lineRepository) { + this.lineRepository = lineRepository; + } + + public List get() { + return lineRepository.lines(); + } +} diff --git a/src/main/java/subway/service/LineRegisterService.java b/src/main/java/subway/service/LineRegisterService.java new file mode 100644 index 000000000..75617e5a0 --- /dev/null +++ b/src/main/java/subway/service/LineRegisterService.java @@ -0,0 +1,35 @@ +package subway.service; + +import subway.domain.line.Line; +import subway.domain.line.LineName; +import subway.exception.SubwayApplicationException; +import subway.exception.line.LineAlreadyExistException; +import subway.exception.station.StationAlreadyExistException; +import subway.repository.line.LineRepository;; +import subway.specification.LineExistSpecification; + +public class LineRegisterService { + private final LineRepository lineRepository; + + public LineRegisterService(LineRepository lineRepository) { + this.lineRepository = lineRepository; + } + + public void register(Line line) { + try { + validateAlreadyExist(line.getName()); + lineRepository.addLine(line); + } catch (StationAlreadyExistException e) { + throw new SubwayApplicationException(e); + } + } + + private void validateAlreadyExist(LineName name) { + LineExistSpecification lineExistSpecification = + new LineExistSpecification(lineRepository); + + if (lineExistSpecification.isSatisfiedBy(name)) { + throw new LineAlreadyExistException(); + } + } +} diff --git a/src/main/java/subway/service/RouteMapService.java b/src/main/java/subway/service/RouteMapService.java new file mode 100644 index 000000000..756d69ace --- /dev/null +++ b/src/main/java/subway/service/RouteMapService.java @@ -0,0 +1,39 @@ +package subway.service; + +import subway.domain.line.Line; +import subway.repository.line.LineRepository; +import subway.view.util.Formatter; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; + +public class RouteMapService { + private static final String DOTS = "---"; + + private final LineRepository lineRepository; + + public RouteMapService(LineRepository lineRepository) { + this.lineRepository = lineRepository; + } + + public String get() { + return toRouteMap(); + } + + private String toRouteMap() { + List routeMap = lineRepository.lines().stream().map(line -> { + List lineMap = new ArrayList<>(); + + lineMap.add(Formatter.Info(line.getName().toString())); + lineMap.add(Formatter.Info(DOTS)); + lineMap.addAll(line.sections().stream() + .map(station -> Formatter.Info(station.getName().toString())) + .collect(Collectors.toList())); + + return String.join(System.lineSeparator(), lineMap); + }).collect(Collectors.toList()); + + return String.join(System.lineSeparator()+System.lineSeparator(), routeMap); + } +} diff --git a/src/main/java/subway/service/SectionDeleteService.java b/src/main/java/subway/service/SectionDeleteService.java new file mode 100644 index 000000000..68780c214 --- /dev/null +++ b/src/main/java/subway/service/SectionDeleteService.java @@ -0,0 +1,38 @@ +package subway.service; + +import subway.domain.line.Line; +import subway.domain.line.LineName; +import subway.domain.station.StationName; +import subway.exception.SubwayApplicationException; +import subway.exception.line.LineNotFoundException; +import subway.exception.line.SectionSizeLowException; +import subway.exception.station.StationNotFoundException; +import subway.repository.line.LineRepository; + +public class SectionDeleteService { + private final LineRepository lineRepository; + + public SectionDeleteService(LineRepository lineRepository) { + this.lineRepository = lineRepository; + } + + public void delete(LineName lineName, StationName stationName) { + try { + deleteStation(lineName, stationName); + } catch (LineNotFoundException | StationNotFoundException | SectionSizeLowException e) { + throw new SubwayApplicationException(e); + } + } + + private void deleteStation(LineName lineName, StationName stationName) { + Line line = findLineByName(lineName); + + if (!line.deleteStationByName(stationName)) { + throw new StationNotFoundException(); + } + } + + private Line findLineByName(LineName lineName) { + return lineRepository.findLineByName(lineName); + } +} diff --git a/src/main/java/subway/service/SectionListService.java b/src/main/java/subway/service/SectionListService.java new file mode 100644 index 000000000..be603493f --- /dev/null +++ b/src/main/java/subway/service/SectionListService.java @@ -0,0 +1,21 @@ +package subway.service; + +import subway.domain.line.Line; +import subway.domain.line.LineName; +import subway.domain.station.Station; +import subway.repository.line.LineRepository; + +import java.util.List; + +public class SectionListService { + private final LineRepository lineRepository; + + public SectionListService(LineRepository lineRepository) { + this.lineRepository = lineRepository; + } + + public List get(LineName lineName) { + Line line = lineRepository.findLineByName(lineName); + return line.sections(); + } +} diff --git a/src/main/java/subway/service/SectionRegisterService.java b/src/main/java/subway/service/SectionRegisterService.java new file mode 100644 index 000000000..e746ce647 --- /dev/null +++ b/src/main/java/subway/service/SectionRegisterService.java @@ -0,0 +1,68 @@ +package subway.service; + +import subway.domain.line.Line; +import subway.domain.line.LineName; +import subway.domain.station.Station; +import subway.domain.station.StationName; +import subway.exception.SubwayApplicationException; +import subway.exception.line.PositionRangeException; +import subway.exception.station.StationAlreadyExistException; +import subway.repository.line.LineRepository; +import subway.repository.station.StationRepository; +import subway.specification.StationExistOnSpecificLineSpecification; + +public class SectionRegisterService { + private final StationRepository stationRepository; + private final LineRepository lineRepository; + + public SectionRegisterService(StationRepository stationRepository, + LineRepository lineRepository) { + this.stationRepository = stationRepository; + this.lineRepository = lineRepository; + } + + public void add(String lineName, String stationName, String position) { + try { + StationName convertedStationName = StationName.of(stationName); + LineName convertedLineName = LineName.of(lineName); + + Station station = findStationFromRepository(convertedStationName); + Line line = findLineFromRepository(convertedLineName); + + isRightPosition(line, toInteger(position)); + validateDuplicateStationOnLine(convertedLineName, station.getName()); + + lineRepository.findLineByName(convertedLineName).add(toInteger(position), station); + } catch (RuntimeException e) { + throw new SubwayApplicationException(e); + } + } + + private int toInteger(String position) { + return Integer.parseInt(position); + } + + + private void isRightPosition(Line line, int position) { + if (!line.isRightPosition(position)) { + throw new PositionRangeException(); + } + } + + private Station findStationFromRepository(StationName stationName) { + return stationRepository.getStationByName(stationName); + } + + private Line findLineFromRepository(LineName lineName) { + return lineRepository.findLineByName(lineName); + } + + private void validateDuplicateStationOnLine(LineName lineName, StationName stationName) { + StationExistOnSpecificLineSpecification stationExistOnSpecificLineSpecification = + new StationExistOnSpecificLineSpecification(lineRepository); + + if (stationExistOnSpecificLineSpecification.isSatisfiedBy(lineName, stationName)) { + throw new StationAlreadyExistException(); + } + } +} diff --git a/src/main/java/subway/service/StationDeleteService.java b/src/main/java/subway/service/StationDeleteService.java new file mode 100644 index 000000000..7fbcd43dc --- /dev/null +++ b/src/main/java/subway/service/StationDeleteService.java @@ -0,0 +1,45 @@ +package subway.service; + +import subway.domain.station.StationName; +import subway.exception.station.StationRegisteredOnLineException; +import subway.exception.SubwayApplicationException; +import subway.exception.station.StationNotFoundException; +import subway.repository.line.LineRepository; +import subway.repository.station.StationRepository; +import subway.specification.StationExistOnLineSpecification; + +public class StationDeleteService { + private final StationRepository stationRepository; + private final LineRepository lineRepository; + + public StationDeleteService(StationRepository stationRepository, + LineRepository lineRepository) { + this.stationRepository = stationRepository; + this.lineRepository = lineRepository; + } + + public void delete(StationName name) { + try { + validateLineContainsStation(name); + deleteStation(name); + } catch (StationNotFoundException | StationRegisteredOnLineException e) { + throw new SubwayApplicationException(e); + } + } + + private void deleteStation(StationName name) { + boolean success = stationRepository.deleteStation(name); + if (!success) { + throw new StationNotFoundException(); + } + } + + private void validateLineContainsStation(StationName name) { + StationExistOnLineSpecification stationExistOnLineSpecification = + new StationExistOnLineSpecification(lineRepository); + + if (stationExistOnLineSpecification.isSatisfiedBy(name)) { + throw new StationRegisteredOnLineException(); + } + } +} diff --git a/src/main/java/subway/service/StationGenerateService.java b/src/main/java/subway/service/StationGenerateService.java new file mode 100644 index 000000000..eb3a5ad17 --- /dev/null +++ b/src/main/java/subway/service/StationGenerateService.java @@ -0,0 +1,22 @@ +package subway.service; + +import subway.domain.station.Station; +import subway.domain.station.StationName; +import subway.exception.station.StationNameFormatException; +import subway.exception.station.StationNameLengthException; +import subway.exception.SubwayApplicationException; + +public class StationGenerateService { + public Station generate(String name) { + Station station; + + try { + StationName stationName = StationName.of(name); + station = Station.of(stationName); + } catch(StationNameFormatException | StationNameLengthException e) { + throw new SubwayApplicationException(e); + } + + return station; + } +} diff --git a/src/main/java/subway/service/StationListService.java b/src/main/java/subway/service/StationListService.java new file mode 100644 index 000000000..50f05729c --- /dev/null +++ b/src/main/java/subway/service/StationListService.java @@ -0,0 +1,18 @@ +package subway.service; + +import subway.domain.station.Station; +import subway.repository.station.StationRepository; + +import java.util.List; + +public class StationListService { + private final StationRepository stationRepository; + + public StationListService(StationRepository stationRepository) { + this.stationRepository = stationRepository; + } + + public List get() { + return stationRepository.stations(); + } +} diff --git a/src/main/java/subway/service/StationRegisterService.java b/src/main/java/subway/service/StationRegisterService.java new file mode 100644 index 000000000..2f12a088b --- /dev/null +++ b/src/main/java/subway/service/StationRegisterService.java @@ -0,0 +1,35 @@ +package subway.service; + +import subway.exception.*; +import subway.domain.station.Station; +import subway.domain.station.StationName; +import subway.exception.station.StationAlreadyExistException; +import subway.repository.station.StationRepository; +import subway.specification.StationExistSpecification; + +public class StationRegisterService { + private final StationRepository stationRepository; + + public StationRegisterService(StationRepository stationRepository) { + this.stationRepository = stationRepository; + } + + public void register(Station station) { + try { + validateAlreadyExist(station.getName()); + stationRepository.addStation(station); + } catch (StationAlreadyExistException e) { + throw new SubwayApplicationException(e); + } + } + + private void validateAlreadyExist(StationName name) { + StationExistSpecification stationExistSpecification = + new StationExistSpecification(stationRepository); + + if (stationExistSpecification.isSatisfiedBy(name)) { + throw new StationAlreadyExistException(); + } + } + +} diff --git a/src/main/java/subway/specification/LineExistSpecification.java b/src/main/java/subway/specification/LineExistSpecification.java new file mode 100644 index 000000000..531ac1528 --- /dev/null +++ b/src/main/java/subway/specification/LineExistSpecification.java @@ -0,0 +1,20 @@ +package subway.specification; + +import subway.domain.line.LineName; +import subway.repository.line.LineRepository; + +import java.util.Objects; + +public class LineExistSpecification { + private final LineRepository lineRepository; + + public LineExistSpecification(LineRepository lineRepository) { + this.lineRepository = lineRepository; + } + + public boolean isSatisfiedBy(LineName name) { + return lineRepository.lines().stream() + .anyMatch(line -> Objects.equals(line.getName(), name)); + } + +} diff --git a/src/main/java/subway/specification/SameUpLineAndDownLineSpecification.java b/src/main/java/subway/specification/SameUpLineAndDownLineSpecification.java new file mode 100644 index 000000000..433b3fdd1 --- /dev/null +++ b/src/main/java/subway/specification/SameUpLineAndDownLineSpecification.java @@ -0,0 +1,11 @@ +package subway.specification; + +import subway.domain.station.Station; + +import java.util.Objects; + +public class SameUpLineAndDownLineSpecification { + public boolean isSatisfiedBy(Station upLine, Station downLine) { + return Objects.equals(upLine, downLine); + } +} diff --git a/src/main/java/subway/specification/StationAlreadyRegisteredSpecification.java b/src/main/java/subway/specification/StationAlreadyRegisteredSpecification.java new file mode 100644 index 000000000..51d98c828 --- /dev/null +++ b/src/main/java/subway/specification/StationAlreadyRegisteredSpecification.java @@ -0,0 +1,23 @@ +package subway.specification; + +import subway.domain.station.Station; +import subway.exception.station.StationNotFoundException; +import subway.repository.station.StationRepository; + +public class StationAlreadyRegisteredSpecification { + StationRepository stationRepository; + + public StationAlreadyRegisteredSpecification(StationRepository stationRepository) { + this.stationRepository = stationRepository; + } + + public boolean isSatisfiedBy(Station station) { + try { + stationRepository.getStationByName(station.getName()); + } catch(StationNotFoundException e) { + return false; + } + + return true; + } +} diff --git a/src/main/java/subway/specification/StationExistOnLineSpecification.java b/src/main/java/subway/specification/StationExistOnLineSpecification.java new file mode 100644 index 000000000..6695f4539 --- /dev/null +++ b/src/main/java/subway/specification/StationExistOnLineSpecification.java @@ -0,0 +1,17 @@ +package subway.specification; + +import subway.domain.station.StationName; +import subway.repository.line.LineRepository; + +public class StationExistOnLineSpecification { + private final LineRepository lineRepository; + + public StationExistOnLineSpecification(LineRepository lineRepository) { + this.lineRepository = lineRepository; + } + + public boolean isSatisfiedBy(StationName name) { + return lineRepository.lines().stream() + .anyMatch(line -> line.contains(name)); + } +} diff --git a/src/main/java/subway/specification/StationExistOnSpecificLineSpecification.java b/src/main/java/subway/specification/StationExistOnSpecificLineSpecification.java new file mode 100644 index 000000000..100f2e322 --- /dev/null +++ b/src/main/java/subway/specification/StationExistOnSpecificLineSpecification.java @@ -0,0 +1,17 @@ +package subway.specification; + +import subway.domain.line.LineName; +import subway.domain.station.StationName; +import subway.repository.line.LineRepository; + +public class StationExistOnSpecificLineSpecification { + private final LineRepository lineRepository; + + public StationExistOnSpecificLineSpecification(LineRepository lineRepository) { + this.lineRepository = lineRepository; + } + + public boolean isSatisfiedBy(LineName lineName, StationName stationName) { + return lineRepository.findLineByName(lineName).contains(stationName); + } +} diff --git a/src/main/java/subway/specification/StationExistSpecification.java b/src/main/java/subway/specification/StationExistSpecification.java new file mode 100644 index 000000000..3f9ad65a9 --- /dev/null +++ b/src/main/java/subway/specification/StationExistSpecification.java @@ -0,0 +1,19 @@ +package subway.specification; + +import subway.domain.station.StationName; +import subway.repository.station.StationRepository; + +import java.util.Objects; + +public class StationExistSpecification { + private final StationRepository stationRepository; + + public StationExistSpecification(StationRepository stationRepository) { + this.stationRepository = stationRepository; + } + + public boolean isSatisfiedBy(StationName name) { + return stationRepository.stations().stream() + .anyMatch(station -> Objects.equals(station.getName(), name)); + } +} diff --git a/src/main/java/subway/view/inputView/InputView.java b/src/main/java/subway/view/inputView/InputView.java new file mode 100644 index 000000000..9ad8d444c --- /dev/null +++ b/src/main/java/subway/view/inputView/InputView.java @@ -0,0 +1,11 @@ +package subway.view.inputView; + +import java.util.Scanner; + +public class InputView { + private static Scanner scanner = new Scanner(System.in); + + public static String scan() { + return scanner.nextLine(); + } +} diff --git a/src/main/java/subway/view/output/LineManagementView.java b/src/main/java/subway/view/output/LineManagementView.java new file mode 100644 index 000000000..d6842ecee --- /dev/null +++ b/src/main/java/subway/view/output/LineManagementView.java @@ -0,0 +1,67 @@ +package subway.view.output; + +import subway.domain.line.Line; +import subway.domain.line.LineName; +import subway.view.util.Formatter; + +import java.util.List; + +public class LineManagementView extends ScreenView { + private static final String LINE = "노선"; + private static final String NAME = "이름"; + private static final String UPLINE_TERMINAL = "상행 종점역"; + private static final String DOWNLINE_TERMINAL = "상행 종점역"; + private static final String LINE_HEADER = "\n## 노선 목록"; + private static final String LINE_REGISTER_START_MESSAGE = "\n## 등록할 노선 이름을 입력하세요."; + private static final String LINE_REGISTER_FINISH_MESSAGE = "\n지하철 노선이 등록되었습니다."; + private static final String LINE_DELETE_MESSAGE = "\n## 삭제할 노선 이름을 입력하세요.."; + private static final String LINE_DELETE_FINISH_MESSAGE = "\n지하철 노선이 삭제되었습니다."; + private static final String LINE_MANAGEMENT_MENU = "\n## 노선 관리 화면\n1. 노선 등록\n2. 노선 삭제\n" + + "3. 노선 조회\nB. 돌아가기\n"; + + + public static void printMenu() { + System.out.println(LINE_MANAGEMENT_MENU);; + } + + public static void printRegisterMessage() { + System.out.println(LINE_REGISTER_START_MESSAGE); + } + + public static void printLineNameInputMessage() { + System.out.println(registerFunction(LINE, NAME)); + } + + public static void printDeleteMessage() { + System.out.println(LINE_DELETE_MESSAGE); + + } + + public static void printDeleteFinishMessage() { + System.out.println(LINE_DELETE_FINISH_MESSAGE); + } + + public static void printUpLineNameInputMessage() { + System.out.println(registerFunction(LINE, UPLINE_TERMINAL)); + } + + public static void printDownLineNameInputMessage() { + System.out.println(registerFunction(LINE, DOWNLINE_TERMINAL)); + } + + public static void printLineRegisteredFinishMessage() { + System.out.println("\n" + Formatter.Info(LINE_REGISTER_FINISH_MESSAGE)); + } + + public static void printLineList(List list) { + System.out.println(LINE_HEADER); + + list.stream() + .map(Line::getName) + .map(LineName::toString) + .map(Formatter::Info) + .forEach(System.out::println); + + System.out.println(); + } +} diff --git a/src/main/java/subway/view/output/MainMenuView.java b/src/main/java/subway/view/output/MainMenuView.java new file mode 100644 index 000000000..74e8e139e --- /dev/null +++ b/src/main/java/subway/view/output/MainMenuView.java @@ -0,0 +1,7 @@ +package subway.view.output; + +public class MainMenuView extends ScreenView { + public static void printMenu(final String menu) { + System.out.println(menu); + } +} diff --git a/src/main/java/subway/view/output/OutputView.java b/src/main/java/subway/view/output/OutputView.java new file mode 100644 index 000000000..e9c433d0f --- /dev/null +++ b/src/main/java/subway/view/output/OutputView.java @@ -0,0 +1,7 @@ +package subway.view.output; + +public class OutputView { + public static void print(String message) { + System.out.println(message); + }; +} diff --git a/src/main/java/subway/view/output/ScreenView.java b/src/main/java/subway/view/output/ScreenView.java new file mode 100644 index 000000000..9d54fa9e9 --- /dev/null +++ b/src/main/java/subway/view/output/ScreenView.java @@ -0,0 +1,26 @@ +package subway.view.output; + +public class ScreenView { + + private static final String CHOOSE_FUNCTION = "\n## 원하는 기능을 선택하세요"; + private static final String REGISTER_FUNCTION = "\n## 등록할 %s %s 이름을 입력하세요"; + private static final String REGISTER_FUNCTION_SINGLE = "\n## 등록할 %s 이름을 입력하세요"; + private static final String DELETE_FUNCTION = "\n## 삭제할 %s을 입력하세요"; + + public static void chooseFunction() { + System.out.println(CHOOSE_FUNCTION); + } + + protected static String registerFunction(String function, String name) { + return String.format(REGISTER_FUNCTION, function, name); + } + + protected static String registerFunction(String function) { + return String.format(REGISTER_FUNCTION_SINGLE, function); + } + + protected static String deleteFunction(String function) { + return String.format(DELETE_FUNCTION, function); + } + +} diff --git a/src/main/java/subway/view/output/SectionManagementView.java b/src/main/java/subway/view/output/SectionManagementView.java new file mode 100644 index 000000000..f46a776e1 --- /dev/null +++ b/src/main/java/subway/view/output/SectionManagementView.java @@ -0,0 +1,46 @@ +package subway.view.output; + +import subway.domain.station.Station; +import subway.domain.station.StationName; +import subway.view.util.Formatter; + +import java.util.List; + +public class SectionManagementView extends ScreenView { + private static final String LINE_INPUT_MESSAGE = "\n## 노선을 입력하세요."; + private static final String STATION_NAME_INPUT_MESSAGE = "\n## 역이름을 입력하세요."; + private static final String POSITION_INPUT_MESSAGE = "\n## 순서를 입력하세요."; + private static final String DELETE_LINE_INPUT_MESSAGE = "\n## 삭제할 구간의 노선을 입력하세요."; + private static final String DELETE_STATION_INPUT_MESSAGE = "\n## 삭제할 구간의 역을 입력하세요."; + + private static final String REGISTER_FINISH_MESSAGE = Formatter.Info("구간이 등록되었습니다."); + private static final String DELETE_FINISH_MESSAGE = Formatter.Info("구간이 삭제되었습니다."); + + public static void printStationNameInputMessage() { + System.out.println(STATION_NAME_INPUT_MESSAGE); + } + + public static void printPositionInputMessage() { + System.out.println(POSITION_INPUT_MESSAGE); + } + + public static void printLineInputMessage() { + System.out.println(LINE_INPUT_MESSAGE); + } + + public static void printRegisterFinishMessage() { + System.out.println("\n" + REGISTER_FINISH_MESSAGE); + } + + public static void printDeleteFinishMessage() { + System.out.println("\n" + DELETE_FINISH_MESSAGE); + } + + public static void printDeleteLineInputMessage() { + System.out.println(DELETE_LINE_INPUT_MESSAGE); + } + + public static void printDeleteStationInputMessage() { + System.out.println(DELETE_STATION_INPUT_MESSAGE); + } +} diff --git a/src/main/java/subway/view/output/StationManagementView.java b/src/main/java/subway/view/output/StationManagementView.java new file mode 100644 index 000000000..ec916e1bb --- /dev/null +++ b/src/main/java/subway/view/output/StationManagementView.java @@ -0,0 +1,40 @@ +package subway.view.output; + +import subway.domain.station.Station; +import subway.domain.station.StationName; +import subway.view.util.Formatter; + +import java.util.List; + +public class StationManagementView extends ScreenView { + private static final String HEADER = "## 역 목록"; + private static final String FUNCTION = "역"; + private static final String REGISTER_FINISH_MESSAGE = Formatter.Info("지하철 역이 등록되었습니다."); + private static final String DELETE_FINISH_MESSAGE = Formatter.Info("지하철 역이 삭제되었습니다."); + + public static void printDeleteMessage() { + System.out.println("\n"+deleteFunction(FUNCTION)); + } + + public static void printRegisterMessage() { + System.out.println(registerFunction(FUNCTION)); + } + + public static void printRegisterFinishMessage() { + System.out.println("\n"+REGISTER_FINISH_MESSAGE); + } + + public static void printDeleteFinishMessage() { + System.out.println("\n"+DELETE_FINISH_MESSAGE); + } + + public static void printStationList(List list) { + System.out.println(HEADER); + + list.stream() + .map(Station::getName) + .map(StationName::toString) + .map(Formatter::Info) + .forEach(System.out::println); + } +} diff --git a/src/main/java/subway/view/util/Formatter.java b/src/main/java/subway/view/util/Formatter.java new file mode 100644 index 000000000..5645a7300 --- /dev/null +++ b/src/main/java/subway/view/util/Formatter.java @@ -0,0 +1,15 @@ +package subway.view.util; + +public class Formatter { + private static final String INFO_PREFIX = "[INFO]"; + private static final String ERROR_PREFIX = "\n[ERROR]"; + private static final String DELIMINATOR = " "; + + public static String Info(String message) { + return String.join(DELIMINATOR, INFO_PREFIX, message); + } + + public static String Error(String message) { + return String.join(DELIMINATOR, ERROR_PREFIX, message+"\n"); + } +}