[라빈] - 체스 스프링 실습 레벨 1 제출합니다

build.gradle

@@ -19,6 +19,7 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-data-jdbc'
 	implementation 'net.rakugakibox.spring.boot:logback-access-spring-boot-starter:2.7.1'
 	implementation 'pl.allegro.tech.boot:handlebars-spring-boot-starter:0.3.1'
+	implementation 'com.google.code.gson:gson:2.8.6'
 	testImplementation 'io.rest-assured:rest-assured:3.3.0'
 	testImplementation('org.springframework.boot:spring-boot-starter-test') {
 		exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'

src/main/java/wooteco/chess/SparkChessApplication.java

@@ -1,22 +1,15 @@
 package wooteco.chess;
 
-import spark.ModelAndView;
-import spark.template.handlebars.HandlebarsTemplateEngine;
+import wooteco.chess.controller.SparkChessController;
 
-import java.util.HashMap;
-import java.util.Map;
-
-import static spark.Spark.get;
+import static spark.Spark.staticFiles;
 
 public class SparkChessApplication {
     public static void main(String[] args) {
-        get("/", (req, res) -> {
-            Map<String, Object> model = new HashMap<>();
-            return render(model, "index.hbs");
-        });
-    }
+        staticFiles.location("/templates/public");
+
+        SparkChessController sparkChessController = new SparkChessController();
 
-    private static String render(Map<String, Object> model, String templatePath) {
-        return new HandlebarsTemplateEngine().render(new ModelAndView(model, templatePath));
+        sparkChessController.route();
     }
 }

src/main/java/wooteco/chess/SpringChessApplication.java

@@ -6,8 +6,8 @@
 @SpringBootApplication
 public class SpringChessApplication {
 
-	public static void main(String[] args) {
-		SpringApplication.run(SpringChessApplication.class, args);
-	}
+    public static void main(String[] args) {
+        SpringApplication.run(SpringChessApplication.class, args);
+    }
 
 }

src/main/java/wooteco/chess/controller/SparkChessController.java

@@ -0,0 +1,122 @@
+package wooteco.chess.controller;
+
+import spark.ModelAndView;
+import spark.Request;
+import spark.Response;
+import spark.template.handlebars.HandlebarsTemplateEngine;
+import wooteco.chess.domain.game.NormalStatus;
+import wooteco.chess.domain.piece.Color;
+import wooteco.chess.domain.position.MovingPosition;
+import wooteco.chess.dto.DestinationPositionDto;
+import wooteco.chess.dto.MovablePositionsDto;
+import wooteco.chess.dto.MoveStatusDto;
+import wooteco.chess.service.ChessWebService;
+
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+
+import static spark.Spark.get;
+import static spark.Spark.post;
+import static wooteco.chess.web.JsonTransformer.json;
+
+public class SparkChessController {
+    private ChessWebService chessWebService;
+
+    public SparkChessController() {
+        this.chessWebService = new ChessWebService();
+    }
+
+    public void route() {
+        get("/", this::index);
+
+        get("/new", this::startNewGame);
+
+        get("/loading", this::loadGame);
+
+        get("/board", (req, res) -> chessWebService.setBoard(), json());
+
+        post("/board", this::postBoard);
+
+        post("/source", this::getMovablePositions, json());
+
+        post("/destination", this::move, json());
+    }
+
+    private String index(Request req, Response res) {
+        Map<String, Object> model = new HashMap<>();
+        model.put("normalStatus", NormalStatus.YES.isNormalStatus());
+
+        return render(model, "index.html");
+    }
+
+    private String startNewGame(Request req, Response res) throws SQLException {
+        Map<String, Object> model = new HashMap<>();
+        model.put("normalStatus", NormalStatus.YES.isNormalStatus());
+
+        chessWebService.clearHistory();
+
+        return render(model, "chess.html");
+    }
+
+    private String loadGame(Request req, Response res) {
+        Map<String, Object> model = new HashMap<>();
+        model.put("normalStatus", NormalStatus.YES.isNormalStatus());
+
+        return render(model, "chess.html");
+    }
+
+    private String postBoard(Request req, Response res) {
+        Map<String, Object> model = new HashMap<>();
+
+        try {
+            MoveStatusDto moveStatusDto = chessWebService.move(new MovingPosition(req.queryParams("source"), req.queryParams("destination")));
+
+            model.put("normalStatus", moveStatusDto.getNormalStatus());
+            model.put("winner", moveStatusDto.getWinner());
+
+            if (moveStatusDto.getWinner().isNone()) {
+                return render(model, "chess.html");
+            }
+            return render(model, "result.html");
+        } catch (IllegalArgumentException | UnsupportedOperationException | NullPointerException | SQLException e) {
+            model.put("normalStatus", NormalStatus.NO.isNormalStatus());
+            model.put("exception", e.getMessage());
+            model.put("winner", Color.NONE);
+            return render(model, "chess.html");
+        }
+    }
+
+    private Map<String, Object> getMovablePositions(Request req, Response res) throws SQLException {
+        Map<String, Object> model = new HashMap<>();
+        try {
+            MovablePositionsDto movablePositionsDto = chessWebService.findMovablePositions(req.queryParams("source"));
+
+            model.put("movable", movablePositionsDto.getMovablePositionNames());
+            model.put("position", movablePositionsDto.getPosition());
+            model.put("normalStatus", NormalStatus.YES.isNormalStatus());
+
+            return model;
+        } catch (IllegalArgumentException | UnsupportedOperationException | NullPointerException e) {
+            model.put("normalStatus", NormalStatus.NO.isNormalStatus());
+            model.put("exception", e.getMessage());
+
+            return model;
+        }
+    }
+
+    private Map<String, Object> move(Request req, Response res) {
+        Map<String, Object> model = new HashMap<>();
+
+        DestinationPositionDto destinationPositionDto = chessWebService.chooseDestinationPosition(req.queryParams("destination"));
+
+        model.put("normalStatus", destinationPositionDto.getNormalStatus().isNormalStatus());
+        model.put("position", destinationPositionDto.getPosition());
+
+        return model;
+    }
+
+    private static String render(Map<String, Object> model, String templatePath) {
+        return new HandlebarsTemplateEngine().render(new ModelAndView(model, templatePath));
+    }
+}

src/main/java/wooteco/chess/controller/ChessController.java → src/main/java/wooteco/chess/controller/SpringChessController.java

@@ -4,7 +4,7 @@
 import org.springframework.web.bind.annotation.GetMapping;
 
 @Controller
-public class ChessController {
+public class SpringChessController {
     @GetMapping("/")
     public String index() {
         return "index";

src/main/java/wooteco/chess/dao/FakeHistoryDao.java

@@ -0,0 +1,35 @@
+package wooteco.chess.dao;
+
+import wooteco.chess.domain.position.MovingPosition;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class FakeHistoryDao {
+    private final Map<Integer, MovingPosition> fakeHistoryDao;
+
+    public FakeHistoryDao() {
+        fakeHistoryDao = new LinkedHashMap<>();
+
+        fakeHistoryDao.put(1, new MovingPosition("a2", "a4"));
+        fakeHistoryDao.put(2, new MovingPosition("a7", "a6"));
+        fakeHistoryDao.put(3, new MovingPosition("a4", "a5"));
+        fakeHistoryDao.put(4, new MovingPosition("b7", "b5"));
+    }
+
+    public Map<Integer, MovingPosition> selectAll() {
+        return fakeHistoryDao;
+    }
+
+    public void clear() {
+        fakeHistoryDao.clear();
+    }
+
+    public void insert(String start, String end) {
+        insert(new MovingPosition(start, end));
+    }
+
+    public void insert(MovingPosition movingPosition) {
+        fakeHistoryDao.put(fakeHistoryDao.size() + 1, movingPosition);
+    }
+}

src/main/java/wooteco/chess/dao/HistoryDao.java

@@ -0,0 +1,43 @@
+package wooteco.chess.dao;
+
+import wooteco.chess.domain.position.MovingPosition;
+import wooteco.chess.web.ConnectionManager;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class HistoryDao {
+    private final ConnectionManager connectionManager = new ConnectionManager();
+
+    public void insert(MovingPosition movingPosition) throws SQLException {
+        String query = "INSERT INTO history (start, end) VALUES (?, ?)";
+        try (PreparedStatement pstmt = connectionManager.getConnection().prepareStatement(query)) {
+            pstmt.setString(1, movingPosition.getStart());
+            pstmt.setString(2, movingPosition.getEnd());
+            pstmt.executeUpdate();
+        }
+    }
+
+    public List<MovingPosition> selectAll() throws SQLException {
+        String query = "SELECT * FROM history";
+        try (PreparedStatement pstmt = connectionManager.getConnection().prepareStatement(query); ResultSet rs = pstmt.executeQuery()) {
+
+            List<MovingPosition> result = new ArrayList<>();
+            while (rs.next()) {
+                result.add(new MovingPosition(rs.getString("start"), rs.getString("end")));
+            }
+            return Collections.unmodifiableList(result);
+        }
+    }
+
+    public void clear() throws SQLException {
+        String query = "DELETE FROM history";
+        try (PreparedStatement pstmt = connectionManager.getConnection().prepareStatement(query)) {
+            pstmt.executeUpdate();
+        }
+    }
+}

src/main/java/wooteco/chess/domain/game/ChessGame.java

@@ -0,0 +1,61 @@
+package wooteco.chess.domain.game;
+
+import wooteco.chess.domain.piece.Color;
+import wooteco.chess.domain.piece.Piece;
+import wooteco.chess.domain.piece.pieces.Pieces;
+import wooteco.chess.domain.piece.pieces.PiecesInitializer;
+import wooteco.chess.domain.position.MovingPosition;
+import wooteco.chess.domain.position.Position;
+import wooteco.chess.domain.position.PositionFactory;
+import wooteco.chess.domain.position.positions.Positions;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ChessGame {
+    private Pieces pieces;
+    private Turn turn;
+
+    public ChessGame() {
+        pieces = PiecesInitializer.operate();
+        turn = new Turn(Color.WHITE);
+    }
+
+    public void move(MovingPosition movingPosition) {
+        pieces.move(movingPosition.getStartPosition(), movingPosition.getEndPosition(), turn.getColor());
+        turn = turn.change();
+    }
+
+    public ScoreResult calculateScore() {
+        return new ScoreResult(pieces);
+    }
+
+    public boolean isKingDead() {
+        return pieces.isKingDead();
+    }
+
+    public Color getAliveKingColor() {
+        return pieces.getAliveKingColor();
+    }
+
+    public Positions findMovablePositions(Position position) {
+        Piece piece = pieces.findBy(position, turn.getColor());
+        return piece.createMovablePositions(pieces.getPieces());
+    }
+
+    public List<String> findMovablePositionNames(String position) {
+        return this.findMovablePositions(PositionFactory.of(position))
+                .getPositions()
+                .stream()
+                .map(Position::toString)
+                .collect(Collectors.toList());
+    }
+
+    public Turn getTurn() {
+        return turn;
+    }
+
+    public Pieces getPieces() {
+        return pieces;
+    }
+}

src/main/java/wooteco/chess/domain/game/NormalStatus.java

@@ -0,0 +1,16 @@
+package wooteco.chess.domain.game;
+
+public enum NormalStatus {
+    YES(true),
+    NO(false);
+
+    private boolean normalStatus;
+
+    NormalStatus(boolean normalStatus) {
+        this.normalStatus = normalStatus;
+    }
+
+    public boolean isNormalStatus() {
+        return normalStatus;
+    }
+}