[라빈] 체스 웹/DB 미션 제출합니다

build.gradle

@@ -14,6 +14,7 @@ dependencies {
     compile('ch.qos.logback:logback-classic:1.2.3')
     testCompile('org.junit.jupiter:junit-jupiter:5.6.0')
     testCompile('org.assertj:assertj-core:3.15.0')
+    compile("mysql:mysql-connector-java:8.0.16")
 }
 
 test {

src/main/java/chess/WebUIChessApplication.java

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

src/main/java/chess/controller/ChessController.java

@@ -1,19 +1,22 @@
 package chess.controller;
 
-import chess.controller.dto.TeamDto;
 import chess.domain.ChessRunner;
+import chess.dto.TeamDTO;
 import chess.view.ConsoleInputView;
 import chess.view.ConsoleOutputView;
 import chess.view.InputView;
 import chess.view.OutputView;
 import org.apache.commons.lang3.StringUtils;
 
+import java.util.Optional;
+
 public class ChessController {
     private static InputView inputView = new ConsoleInputView();
     private static OutputView outputView = new ConsoleOutputView();
 
     public static void start() {
-        Command command = getCommand();
+        outputView.printGameRule();
+        Command command = getGameCommand();
         if (command.isStart()) {
             ChessRunner chessRunner = new ChessRunner();
             GameController gameController = command.getGameController();
@@ -23,13 +26,22 @@ public static void start() {
         }
     }
 
-    private static Command getCommand() {
-        try {
-            return Command.of(inputView.askChessRun());
-        } catch (IllegalArgumentException e) {
-            System.out.println(e.getMessage());
-            return getCommand();
+    private static Command getGameCommand() {
+        Optional<Command> command = Optional.empty();
+
+        do {
+            command = Command.of(inputView.askGameCommand());
+        } while (isEmptyCommand(command));
+        return command.get();
+    }
+
+    private static boolean isEmptyCommand(Optional<Command> command) {
+        if (command.isPresent()) {
+            return false;
         }
+
+        System.out.println("잘못된 명령어를 입력하였습니다.");
+        return true;
     }
 
     private static void runChessGame(Command command, ChessRunner chessRunner) {
@@ -41,19 +53,29 @@ private static void runChessGame(Command command, ChessRunner chessRunner) {
 
     private static Command validateExecute(Command command, ChessRunner chessRunner) {
         try {
-            String commands = inputView.askGameCommand();
-            command = Command.of(commands);
-            GameController gameController = command.getGameController();
-            gameController.execute(chessRunner, commands);
-        } catch (IllegalArgumentException e) {
+            command = executeByCommand(command, chessRunner);
+        } catch (IllegalArgumentException | ArrayIndexOutOfBoundsException e) {
             System.out.println(e.getMessage());
         }
         return command;
     }
 
+    private static Command executeByCommand(Command command, ChessRunner chessRunner) {
+        String input = inputView.askGameCommand();
+        Optional<Command> inputCommand = Command.of(input);
+
+        while (isEmptyCommand(inputCommand)) {
+            input = inputView.askGameCommand();
+            inputCommand = Command.of(input);
+        }
+        command = inputCommand.get();
+        command.execute(chessRunner, input);
+        return command;
+    }
+
     private static void printWinner(ChessRunner chessRunner) {
         if (chessRunner.isEndChess()) {
-            TeamDto teamDto = new TeamDto(chessRunner.getWinner());
+            TeamDTO teamDto = new TeamDTO(chessRunner.getWinner());
             outputView.printWinner(teamDto.getTeamName());
         }
     }

src/main/java/chess/controller/Command.java

@@ -1,6 +1,9 @@
 package chess.controller;
 
+import chess.domain.ChessRunner;
+
 import java.util.Arrays;
+import java.util.Optional;
 
 public enum Command {
     START("start", new StartController()),
@@ -16,11 +19,10 @@ public enum Command {
         this.gameController = gameController;
     }
 
-    public static Command of(final String command) {
+    public static Optional<Command> of(final String command) {
         return Arrays.stream(values())
                 .filter(c -> command.contains(c.command))
-                .findFirst()
-                .orElseThrow(() -> new IllegalArgumentException("잘못된 명령어를 입력하였습니다."));
+                .findFirst();
     }
 
     public boolean isStart() {
@@ -34,4 +36,8 @@ public GameController getGameController() {
     public boolean isEnd() {
         return this == END;
     }
+
+    public void execute(ChessRunner chessRunner, String commands) {
+        this.gameController.execute(chessRunner, commands);
+    }
 }

src/main/java/chess/controller/GameController.java

@@ -1,9 +1,9 @@
 package chess.controller;
 
-import chess.controller.dto.BoardDto;
-import chess.controller.dto.PositionDto;
 import chess.domain.ChessRunner;
 import chess.domain.position.Position;
+import chess.dto.BoardDTO;
+import chess.dto.PositionDTO;
 import chess.view.ConsoleOutputView;
 import chess.view.OutputView;
 
@@ -17,8 +17,8 @@ public GameController() {
     }
 
     protected void printBoard(final Map<String, String> board) {
-        BoardDto boardDto = new BoardDto(board);
-        PositionDto positionDto = new PositionDto(Position.getPositions());
+        BoardDTO boardDto = new BoardDTO(board);
+        PositionDTO positionDto = new PositionDTO(Position.getPositions());
         this.outputView.printBoard(positionDto.getPositions(), boardDto.get());
     }
 

src/main/java/chess/controller/StatusController.java

@@ -1,19 +1,27 @@
 package chess.controller;
 
-import chess.controller.dto.BoardScoreDto;
-import chess.controller.dto.TeamDto;
 import chess.domain.ChessRunner;
+import chess.dto.BoardScoreDTO;
+
+import java.util.List;
+import java.util.stream.Collectors;
 
 public class StatusController extends GameController {
+    private static final String DELIMITER = ": ";
+    private static final String NEW_LINE = "\n";
+
     public StatusController() {
         super();
     }
 
     @Override
     public void execute(ChessRunner chessRunner, String input) {
-        BoardScoreDto boardScoreDto = new BoardScoreDto(chessRunner.calculateScore());
-        TeamDto teamDto = new TeamDto(chessRunner.getCurrentTeam());
-        outputView.printStatus(boardScoreDto.getBoardScore(), teamDto.getTeamName());
+        List<BoardScoreDTO> boardScoreDtos = chessRunner.calculateScores();
+        String scores = boardScoreDtos.stream()
+                .map(dto -> dto.getTeam() + DELIMITER + dto.getBoardScore())
+                .collect(Collectors.joining(NEW_LINE));
+
+        outputView.printStatus(scores);
         printBoard(chessRunner.getBoardEntities());
     }
 }

src/main/java/chess/controller/WebChessController.java

@@ -0,0 +1,181 @@
+package chess.controller;
+
+import chess.dao.ChessBoard;
+import chess.dao.CustomSQLException;
+import chess.dao.Player;
+import chess.dto.MoveResultDTO;
+import chess.dto.TeamDTO;
+import chess.dto.TileDTO;
+import chess.service.ChessService;
+import spark.ModelAndView;
+import spark.template.handlebars.HandlebarsTemplateEngine;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static spark.Spark.get;
+import static spark.Spark.post;
+
+public class WebChessController {
+    private ChessService chessService;
+
+    public void playChess() {
+        this.chessService = new ChessService();
+
+        get("/", (req, res) -> {
+            Map<String, Object> model = new HashMap<>();
+
+            return render(model, "index.html");
+        });
+
+        post("/name", (req, res) -> {
+            Map<String, Object> model = new HashMap<>();
+
+            return render(model, "name.html");
+        });
+
+        post("/load", (req, res) -> {
+            Map<String, Object> model = new HashMap<>();
+
+            try {
+                List<Player> players = this.chessService.players();
+
+                model.put("gameData", players);
+
+                return render(model, "table.html");
+            } catch (CustomSQLException e) {
+                model.put("errMessage", e.getMessage());
+                return render(model, "error.html");
+            }
+        });
+
+        post("/newGame", (req, res) -> {
+            Map<String, Object> model = new HashMap<>();
+
+            String whitePlayer = req.queryParams("white-player");
+            String blackPlayer = req.queryParams("black-player");
+
+            try {
+                Player player = new Player(whitePlayer, blackPlayer);
+                this.chessService.newGame(player);
+                List<TileDTO> tileDtos = this.chessService.getTiles();
+                TeamDTO teamDto = this.chessService.getCurrentTeam();
+                ChessBoard chessBoard = this.chessService.getRecentChessBoard();
+
+                model.put("tiles", tileDtos);
+                model.put("currentTeam", teamDto);
+                model.put("player", player);
+                model.put("chessBoard", chessBoard);
+
+                return render(model, "game.html");
+            } catch (CustomSQLException e) {
+                model.put("errMessage", e.getMessage());
+                return render(model, "error.html");
+            }
+        });
+
+        post("/continueGame", (req, res) -> {
+            Map<String, Object> model = new HashMap<>();
+
+            int chessBoardId = Integer.parseInt(req.queryParams("chess-board-id"));
+
+            try {
+                this.chessService.continueGame(chessBoardId);
+                List<TileDTO> tileDtos = this.chessService.getTiles();
+                TeamDTO teamDto = this.chessService.getCurrentTeam();
+                Player player = this.chessService.getPlayer(chessBoardId);
+                ChessBoard chessBoard = new ChessBoard(chessBoardId);
+
+                model.put("tiles", tileDtos);
+                model.put("currentTeam", teamDto);
+                model.put("player", player);
+                model.put("chessBoard", chessBoard);
+
+                return render(model, "game.html");
+            } catch (CustomSQLException e) {
+                model.put("errMessage", e.getMessage());
+                return render(model, "error.html");
+            }
+        });
+
+        post("/move", (req, res) -> {
+            Map<String, Object> model = new HashMap<>();
+
+            int chessBoardId = Integer.parseInt(req.queryParams("chess-board-id"));
+            String source = req.queryParams("source");
+            String target = req.queryParams("target");
+
+            try {
+                MoveResultDTO moveResultDto = this.chessService.move(chessBoardId, source, target);
+                List<TileDTO> tileDtos = this.chessService.getTiles();
+                TeamDTO teamDto = this.chessService.getCurrentTeam();
+                Player player = this.chessService.getPlayer(chessBoardId);
+                ChessBoard chessBoard = new ChessBoard(chessBoardId);
+
+                model.put("tiles", tileDtos);
+                model.put("currentTeam", teamDto);
+                model.put("message", moveResultDto.getMessage());
+                model.put("style", moveResultDto.getStyle());
+                model.put("player", player);
+                model.put("chessBoard", chessBoard);
+
+                if (this.chessService.isEndGame()) {
+                    this.chessService.deleteChessGame(chessBoardId);
+                    return render(model, "end.html");
+                }
+                return render(model, "game.html");
+            } catch (CustomSQLException e) {
+                model.put("errorMessage", e.getMessage());
+                return render(model, "error.html");
+            }
+        });
+
+        post("/status", (req, res) -> {
+            Map<String, Object> model = new HashMap<>();
+
+            int chessBoardId = Integer.parseInt(req.queryParams("chess-board-id-status"));
+
+            try {
+                List<TileDTO> tileDtos = this.chessService.getTiles();
+                TeamDTO teamDto = this.chessService.getCurrentTeam();
+                String message = this.chessService.getScores();
+                Player player = this.chessService.getPlayer(chessBoardId);
+                ChessBoard chessBoard = new ChessBoard(chessBoardId);
+
+                model.put("tiles", tileDtos);
+                model.put("currentTeam", teamDto);
+                model.put("message", message);
+                model.put("player", player);
+                model.put("chessBoard", chessBoard);
+
+                return render(model, "game.html");
+            } catch (CustomSQLException e) {
+                model.put("errorMessage", e.getMessage());
+                return render(model, "error.html");
+            }
+        });
+
+        post("/end", (req, res) -> {
+            Map<String, Object> model = new HashMap<>();
+
+            int chessBoardId = Integer.parseInt(req.queryParams("chess-board-id-end"));
+
+            try {
+                this.chessService.deleteChessGame(chessBoardId);
+                String message = this.chessService.getScores();
+
+                model.put("message", message);
+
+                return render(model, "end.html");
+            } catch (CustomSQLException e) {
+                model.put("errorMessage", e.getMessage());
+                return render(model, "error.html");
+            }
+        });
+    }
+
+    private static String render(Map<String, Object> model, String templatePath) {
+        return new HandlebarsTemplateEngine().render(new ModelAndView(model, templatePath));
+    }
+}