Step3리뷰 요청드립니다.

build.gradle

@@ -17,6 +17,11 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-web'
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
 
+    // https://mvnrepository.com/artifact/org.projectlombok/lombok
+    compileOnly 'org.projectlombok:lombok:1.18.24'
+    annotationProcessor 'org.projectlombok:lombok:1.18.24'
+    implementation 'org.apache.commons:commons-text:1.9'
+
     // log
     implementation 'net.rakugakibox.spring.boot:logback-access-spring-boot-starter:2.7.1'
 

src/main/java/nextstep/subway/applicaion/common/DuplicatedDownStationException.java

@@ -0,0 +1,12 @@
+package nextstep.subway.applicaion.common;
+
+import com.sun.jdi.request.DuplicateRequestException;
+
+import java.util.NoSuchElementException;
+
+public class DuplicatedDownStationException extends DuplicateRequestException {
+
+    public DuplicatedDownStationException() {
+        super("하행역이 이미 존재하는 역입니다.");
+    }
+}

src/main/java/nextstep/subway/applicaion/common/ErrorController.java

@@ -0,0 +1,24 @@
+package nextstep.subway.applicaion.common;
+
+import com.sun.jdi.request.DuplicateRequestException;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+
+import java.util.NoSuchElementException;
+
+@RestControllerAdvice
+public class ErrorController {
+
+    @ExceptionHandler(value = NoSuchElementException.class)
+    public ResponseEntity<ErrorResponse> noElementAdviser(NoSuchElementException e) {
+        return new ResponseEntity<>(new ErrorResponse(e.getMessage(), HttpStatus.NOT_FOUND), HttpStatus.NOT_FOUND);
+    }
+
+    @ExceptionHandler(value = {IllegalArgumentException.class, DuplicateRequestException.class})
+    public ResponseEntity<ErrorResponse> noElementAdviser(RuntimeException e) {
+        return new ResponseEntity<>(new ErrorResponse(e.getMessage(), HttpStatus.BAD_REQUEST), HttpStatus.BAD_REQUEST);
+    }
+}

src/main/java/nextstep/subway/applicaion/common/ErrorResponse.java

@@ -0,0 +1,31 @@
+package nextstep.subway.applicaion.common;
+
+import org.springframework.http.HttpStatus;
+
+import java.time.LocalDateTime;
+
+public class ErrorResponse {
+
+	private LocalDateTime timestamp = LocalDateTime.now();
+
+	private String message;
+
+	private HttpStatus status;
+
+	public LocalDateTime getTimestamp() {
+		return timestamp;
+	}
+
+	public String getMessage() {
+		return message;
+	}
+
+	public HttpStatus getStatus() {
+		return status;
+	}
+
+	public ErrorResponse(String message, HttpStatus status) {
+		this.message = message;
+		this.status = status;
+	}
+}

src/main/java/nextstep/subway/applicaion/common/LineNotFoundException.java

@@ -0,0 +1,10 @@
+package nextstep.subway.applicaion.common;
+
+import java.util.NoSuchElementException;
+
+public class LineNotFoundException extends NoSuchElementException {
+
+    public LineNotFoundException() {
+        super("해당 노선이 존재하지 않습니다.");
+    }
+}

src/main/java/nextstep/subway/applicaion/common/MinimumSectionException.java

@@ -0,0 +1,7 @@
+package nextstep.subway.applicaion.common;
+
+public class MinimumSectionException extends IllegalArgumentException {
+    public MinimumSectionException() {
+        super("해당 라인의 구간 갯수가 최소 갯수이므로 삭제가 불가능합니다.");
+    }
+}

src/main/java/nextstep/subway/applicaion/common/SectionNotFoundException.java

@@ -0,0 +1,10 @@
+package nextstep.subway.applicaion.common;
+
+import java.util.NoSuchElementException;
+
+public class SectionNotFoundException extends NoSuchElementException {
+
+    public SectionNotFoundException() {
+        super("해당 구간이 존재하지 않습니다.");
+    }
+}

src/main/java/nextstep/subway/applicaion/common/StationNotFoundException.java

@@ -0,0 +1,10 @@
+package nextstep.subway.applicaion.common;
+
+import java.util.NoSuchElementException;
+
+public class StationNotFoundException extends NoSuchElementException {
+
+    public StationNotFoundException() {
+        super("해당 역이 존재하지 않습니다.");
+    }
+}

src/main/java/nextstep/subway/applicaion/common/UnappropriateStationException.java

@@ -0,0 +1,8 @@
+package nextstep.subway.applicaion.common;
+
+public class UnappropriateStationException extends IllegalArgumentException {
+
+    public UnappropriateStationException() {
+        super("역이 해당 라인의 하행종점역이 아닙니다.");
+    }
+}

src/main/java/nextstep/subway/applicaion/line/LineService.java

@@ -0,0 +1,70 @@
+package nextstep.subway.applicaion.line;
+
+import nextstep.subway.applicaion.common.LineNotFoundException;
+import nextstep.subway.applicaion.line.domain.Line;
+import nextstep.subway.applicaion.line.domain.LineRepository;
+import nextstep.subway.applicaion.line.dto.LineRequest;
+import nextstep.subway.applicaion.line.dto.LineResponse;
+import nextstep.subway.applicaion.line.dto.LineUpdateRequest;
+import nextstep.subway.applicaion.section.SectionService;
+import nextstep.subway.applicaion.station.StationService;
+import nextstep.subway.applicaion.station.domain.Station;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+@Transactional(readOnly = true)
+public class LineService {
+    private final LineRepository lineRepository;
+    private final StationService stationService;
+    private final SectionService sectionService;
+    public LineService(LineRepository lineRepository, StationService stationService, SectionService sectionService) {
+        this.lineRepository = lineRepository;
+        this.stationService = stationService;
+        this.sectionService = sectionService;
+    }
+    @Transactional
+    public LineResponse saveLine(LineRequest lineRequest) {
+        Station upStation = stationService.getStationThrowExceptionIfNotExists(lineRequest.getUpStationId());
+        Station downStation = stationService.getStationThrowExceptionIfNotExists(lineRequest.getDownStationId());
+
+        Line line = lineRepository.save(lineRequest.toLine());
+        line.getSections().initializeLine(line, upStation, downStation, lineRequest.getDistance());
+
+        return createLineResponse(line);
+    }
+
+    public List<LineResponse> findAllLines() {
+        List<Line> lines = lineRepository.findAll();
+
+        return lines.stream().map(this::createLineResponse).collect(Collectors.toList());
+    }
+
+    public LineResponse findLineById(Long id) {
+        Line line = lineRepository.findById(id).orElseThrow(LineNotFoundException::new);
+
+        return createLineResponse(line);
+    }
+
+    @Transactional
+    public void updateLineById(Long id, LineUpdateRequest lineRequest) {
+        Line line = lineRepository.findById(id).orElseThrow(LineNotFoundException::new);
+        line.updateLineInfo(lineRequest.getName(), lineRequest.getColor());
+    }
+
+    @Transactional
+    public void deleteLineById(Long id) {
+        lineRepository.deleteById(id);
+    }
+
+    private LineResponse createLineResponse(Line line) {
+        return new LineResponse(
+                line.getId(),
+                line.getName(),
+                line.getColor(),
+                line.getSections().stations().stream().map(stationService::createStationResponse).collect(Collectors.toList()));
+    }
+}

src/main/java/nextstep/subway/applicaion/line/domain/Line.java

@@ -0,0 +1,30 @@
+package nextstep.subway.applicaion.line.domain;
+
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.*;
+
+@Getter
+@Entity
+@NoArgsConstructor
+public class Line {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+    @Column(unique = true)
+    private String name;
+    private String color;
+    @Embedded
+    private Sections sections = new Sections();
+
+    public Line(String name, String color) {
+        this.name = name;
+        this.color = color;
+    }
+
+    public void updateLineInfo(String name, String color) {
+        this.name = name;
+        this.color = color;
+    }
+}

src/main/java/nextstep/subway/applicaion/line/domain/LineRepository.java

@@ -0,0 +1,6 @@
+package nextstep.subway.applicaion.line.domain;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface LineRepository extends JpaRepository<Line, Long> {
+}

src/main/java/nextstep/subway/applicaion/line/domain/Sections.java

@@ -0,0 +1,101 @@
+package nextstep.subway.applicaion.line.domain;
+
+import nextstep.subway.applicaion.common.DuplicatedDownStationException;
+import nextstep.subway.applicaion.common.MinimumSectionException;
+import nextstep.subway.applicaion.common.SectionNotFoundException;
+import nextstep.subway.applicaion.common.UnappropriateStationException;
+import nextstep.subway.applicaion.section.domain.Section;
+import nextstep.subway.applicaion.station.domain.Station;
+
+import javax.persistence.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Embeddable
+public class Sections {
+    private final Integer MINIMUM_SECTION_SIZE = 3;
+    @OneToMany(fetch = FetchType.LAZY, cascade = {CascadeType.MERGE, CascadeType.PERSIST}, orphanRemoval = true)
+    @JoinColumn(name = "line_id")
+    private List<Section> sections = new ArrayList<>();
+
+    public void initializeLine(Line line, Station upStation, Station downStation, Integer distance) {
+        addFirstMark(line, upStation);
+        addLastMark(line, downStation);
+        this.add(line, upStation, downStation, distance);
+    }
+
+    public void addLast(Line line, Station upStation, Station downStation, Integer distance) {
+        this.add(line, upStation, downStation, distance);
+        addLastMark(line, downStation);
+    }
+
+    public void addFirst(Line line, Station upStation, Station downStation, Integer distance) {
+        this.add(line, upStation, downStation, distance);
+        addFirstMark(line, upStation);
+    }
+
+    public List<Station> stations() {
+        return sections.stream().map(it -> it.upStation).filter(Objects::nonNull).collect(Collectors.toList());
+    }
+
+    public void removeStation(Long stationId) {
+        if (sections.size() <= MINIMUM_SECTION_SIZE) {
+            throw new MinimumSectionException();
+        }
+
+        Section lastSectionMark = getLastSection().get();
+        if (!Objects.equals(lastSectionMark.upStation.getId(), stationId)) {
+            throw new UnappropriateStationException();
+        }
+        sections.remove(lastSectionMark);
+
+        Section lastSection = sections.stream().filter(it -> Objects.equals(it.downStation.getId(), stationId)).findFirst().get();
+        lastSection.downStation = null;
+    }
+
+    public void checkIsLastStation(Station upStation) {
+        if (!Objects.equals(getLastStation().getId(), upStation.getId())) {
+            throw new UnappropriateStationException();
+        }
+    }
+
+    public void checkIsNewStation(Station downStation) {
+        stations().forEach(it -> {
+            if (Objects.equals(it.getId(), downStation.getId())) {
+                throw new DuplicatedDownStationException();
+            }
+        });
+    }
+
+    private void addLastMark(Line line, Station downStation) {
+        getLastSection().ifPresent(it -> sections.remove(it));
+        Section lastSection = new Section(downStation, null, 0, line);
+        sections.add(lastSection);
+    }
+
+    private void addFirstMark(Line line, Station upStation) {
+        getFirstSection().ifPresent(it -> sections.remove(it));
+        Section firstSection = new Section(null, upStation, 0, line);
+        sections.add(firstSection);
+    }
+
+    private Optional<Section> getLastSection() {
+        return sections.stream().filter(it -> it.downStation == null).findFirst();
+    }
+
+    private Optional<Section> getFirstSection() {
+        return sections.stream().filter(it -> it.upStation == null).findFirst();
+    }
+
+    private void add(Line line, Station upStation, Station downStation, Integer distance) {
+        Section section = new Section(upStation, downStation, distance, line);
+        sections.add(section);
+    }
+
+    private Station getLastStation() {
+        return getLastSection().orElseThrow(SectionNotFoundException::new).upStation;
+    }
+}

src/main/java/nextstep/subway/applicaion/line/dto/LineRequest.java

@@ -0,0 +1,43 @@
+package nextstep.subway.applicaion.line.dto;
+
+import nextstep.subway.applicaion.line.domain.Line;
+
+public class LineRequest {
+	private String name;
+	private String color;
+	private Long upStationId;
+	private Long downStationId;
+	private Integer distance;
+
+	public Long getUpStationId() {
+		return upStationId;
+	}
+
+	public Long getDownStationId() {
+		return downStationId;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public String getColor() {
+		return color;
+	}
+
+	public Integer getDistance() {
+		return distance;
+	}
+
+	public LineRequest(String name, String color, Long upStationId, Long downStationId, Integer distance) {
+		this.name = name;
+		this.color = color;
+		this.upStationId = upStationId;
+		this.downStationId = downStationId;
+		this.distance = distance;
+	}
+
+	public Line toLine() {
+		return new Line(name, color);
+	}
+}