Scoreboard command added, close #47

src/main/java/lar/minecraft/hg/SpigotPlugin.java

@@ -9,6 +9,7 @@
 import org.bukkit.plugin.java.JavaPlugin;
 
 import lar.minecraft.hg.commands.ClassCommand;
+import lar.minecraft.hg.commands.ScoreboardCommand;
 import lar.minecraft.hg.commands.TestCommand;
 import lar.minecraft.hg.enums.ConfigProperty;
 import lar.minecraft.hg.enums.HGPhase;
@@ -48,8 +49,12 @@ public void onEnable() {
     	// Initialize MessageUtils for messages
     	MessageUtils.init();
 
-    	// Instantiate database connection and connect
-    	new DatabaseManager(true);
+    	// Initiate DB connection and connect to database
+    	boolean databaseEnabled = ConfigUtils.getBoolean(ConfigProperty.database_enable);
+		String dbConnectionString = ConfigUtils.getString(ConfigProperty.database_connection_string); 
+		String dbUser = ConfigUtils.getString(ConfigProperty.database_user);
+		String dbPassword = ConfigUtils.getString(ConfigProperty.database_password);
+    	DatabaseManager.Init(databaseEnabled, dbConnectionString, dbUser, dbPassword);
 
         // Enable test commands
         getCommand("start-hg").setExecutor(new TestCommand(this));
@@ -58,6 +63,10 @@ public void onEnable() {
         getCommand("test").setExecutor(new TestCommand(this));
         getCommand("messages").setExecutor(new TestCommand(this));
 
+        // Enable game commands
+        getCommand("scoreboard").setExecutor(new ScoreboardCommand());
+		getCommand("scoreboard").setTabCompleter(new ScoreboardCommand());
+
         // Enable class selection commands
         Arrays.asList(PlayerClass.values()).forEach(c -> {
         	getCommand(c.name()).setExecutor(new ClassCommand());

src/main/java/lar/minecraft/hg/commands/ScoreboardCommand.java

@@ -0,0 +1,84 @@
+package lar.minecraft.hg.commands;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+
+import lar.minecraft.hg.entities.PlayerExtra;
+import lar.minecraft.hg.enums.MessageKey;
+import lar.minecraft.hg.managers.DatabaseManager;
+import lar.minecraft.hg.managers.PlayerManager;
+import lar.minecraft.hg.utils.MessageUtils;
+
+public class ScoreboardCommand implements CommandExecutor, TabExecutor {
+
+	@Override
+	public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+		Player player = (Player) sender;
+
+		if (args.length == 1) {
+			// Global scoreboard
+			if (args[0].equalsIgnoreCase("global")) {
+				player.sendMessage(MessageUtils.getMessage(MessageKey.scoreboard_list_header));
+
+				// Get global scoreboard
+				Map<String, Integer> globalScoreboard = DatabaseManager.getGlobalScoreboard();
+				// Order scoreboard, limit to 10 records and print it
+		    	globalScoreboard.entrySet()
+		    		.stream()
+			    	.sorted(new Comparator<Entry<String, Integer>>() {
+						@Override
+						public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
+							return o2.getValue() - o1.getValue();
+						}
+					})
+			    	.limit(10)
+			    	.forEach((x) -> {
+			    		player.sendMessage(String.format("%s --> %d", x.getKey(), x.getValue()));
+			    	});;
+
+			} else {
+				return false;
+			}
+		} else {
+			player.sendMessage(MessageUtils.getMessage(MessageKey.scoreboard_list_header));
+
+			// Order scoreboard, limit to 10 records and print it
+			PlayerManager.playerExtras.values().stream()
+				.sorted(new Comparator<PlayerExtra>() {
+					@Override
+					public int compare(PlayerExtra o1, PlayerExtra o2) {
+		    			return o2.getWinCount() - o1.getWinCount();
+					}
+				})
+				.limit(10)
+				.forEach(x -> {
+		    		player.sendMessage(String.format("%s --> %d", x.getName(), x.getWinCount()));
+				});
+		}
+
+		return true;
+	}
+
+	@Override
+	public List<String> onTabComplete(CommandSender sender, Command cmd, String label, String[] args) {
+		List<String> completions = new ArrayList<>();
+
+		if (args.length == 1) {
+			completions.add("global");
+			return completions;
+		}
+
+		Collections.sort(completions);
+		return Collections.emptyList();
+	}
+
+}

src/main/java/lar/minecraft/hg/entities/PlayerExtra.java

@@ -7,22 +7,30 @@
 public class PlayerExtra {
 
 	private UUID uuid;
+	private String name;
 	private PlayerClass playerClass = null;
 	private boolean lastWinner = false;
 	private boolean premium = false;
+	private int winCount = 0;
 
-	public PlayerExtra(UUID uuid) {
-		this(uuid, false);
+	public PlayerExtra(UUID uuid, String name) {
+		this(uuid, name, false);
 	}
 
-	public PlayerExtra(UUID uuid, boolean lastWinner) {
-		this(uuid, lastWinner, false);
+	public PlayerExtra(UUID uuid, String name, boolean lastWinner) {
+		this(uuid, name, lastWinner, false);
 	}
 
-	public PlayerExtra(UUID uuid, boolean lastWinner, boolean premium) {
+	public PlayerExtra(UUID uuid, String name, boolean lastWinner, boolean premium) {
+		this(uuid, name, lastWinner, false, 0);
+	}
+
+	public PlayerExtra(UUID uuid, String name, boolean lastWinner, boolean premium, int winCount) {
 		this.uuid = uuid;
+		this.name = name;
 		this.lastWinner = lastWinner;
 		this.premium = premium;
+		this.winCount = winCount;
 	}
 
 	public UUID getUuid() {
@@ -33,6 +41,14 @@ public void setUuid(UUID uuid) {
 		this.uuid = uuid;
 	}
 
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
 	public PlayerClass getPlayerClass() {
 		return playerClass;
 	}
@@ -56,6 +72,14 @@ public boolean isPremium() {
 	public void setPremium(boolean premium) {
 		this.premium = premium;
 	}
+
+	public int getWinCount() {
+		return winCount;
+	}
+
+	public void setWinCount(int winCount) {
+		this.winCount = winCount;
+	}
 
 	@Override
 	public int hashCode() {
@@ -81,5 +105,4 @@ public boolean equals(Object obj) {
 			return false;
 		return true;
 	}
-
-}
+}

src/main/java/lar/minecraft/hg/enums/MessageKey.java

@@ -15,5 +15,6 @@ public enum MessageKey {
 	safe_area_phase_alert,
 	safe_area_expires_alert,
 	playing_phase_alert,
-	server_to_restart_alert
+	server_to_restart_alert,
+	scoreboard_list_header
 }

src/main/java/lar/minecraft/hg/managers/DatabaseManager.java

@@ -5,12 +5,11 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
+import java.util.HashMap;
+import java.util.Map;
 
 import org.bukkit.entity.Player;
 
-import lar.minecraft.hg.enums.ConfigProperty;
-import lar.minecraft.hg.utils.ConfigUtils;
-
 public class DatabaseManager {
 
 	private static boolean databaseEnabled = false;
@@ -22,26 +21,31 @@ public class DatabaseManager {
 	public static boolean isDatabaseEnabled() {
 		return databaseEnabled;
 	}
+
+	public static String getDbConnectionString() {
+		return dbConnectionString;
+	}
 
-	/*
-	 * TODO Maybe can be used init method as was done for ServerSchedulers. 
-	 * Maybe also we can remove "directlyConnect" boolean variable because never really used: if it's false, what happen?
+	/**
+	 * Initiate DB connection and connect to database
+	 * @param databaseEnabled If true a Database connection will be instantiated with the passed parameters
+	 * @param connectionString Database connection String
+	 * @param dbUser Database user (user must have permission to create tables and views)
+	 * @param dbPassword Database user password
 	 */
-	public DatabaseManager(boolean directlyConnect) {
-		databaseEnabled = ConfigUtils.getBoolean(ConfigProperty.database_enable);
+	public static void Init(boolean databaseEnabled, String connectionString, String dbUser, String dbPassword) {
+		DatabaseManager.databaseEnabled = databaseEnabled;
 
-		// Directly connect to database when creating Database Manager
+		// Set static fields and connect to database
 		if (isDatabaseEnabled()) {
-			dbConnectionString = ConfigUtils.getString(ConfigProperty.database_connection_string); 
-			dbUser = ConfigUtils.getString(ConfigProperty.database_user);
-			dbPassword = ConfigUtils.getString(ConfigProperty.database_password);
+			DatabaseManager.dbConnectionString = connectionString; 
+			DatabaseManager.dbUser = dbUser;
+			DatabaseManager.dbPassword = dbPassword;
 
-			if (directlyConnect) {
-				try {
-					connectToDatabase();
-				} catch (ClassNotFoundException | SQLException e) {
-					e.printStackTrace();
-				}
+			try {
+				connectToDatabase();
+			} catch (ClassNotFoundException | SQLException e) {
+				e.printStackTrace();
 			}
 		}
 	}
@@ -90,9 +94,21 @@ public static int createTables() {
 		if (isDatabaseEnabled()) {
 			try {
 				Statement statementCreate = dbConnection.createStatement();
-				statementCreate.executeUpdate(String.format("CREATE TABLE IF NOT EXISTS hg_games (server_id int NOT NULL, id int NOT NULL, winner_uuid varchar(100), win_datetime datetime)"));
-				statementCreate.executeUpdate(String.format("CREATE TABLE IF NOT EXISTS played_hg_games (server_id int NOT NULL, id int NOT NULL, player_uuid varchar(100))"));
-				statementCreate.executeUpdate(String.format("CREATE TABLE IF NOT EXISTS players (uuid varchar(100), name varchar(100))"));
+				statementCreate.executeUpdate("CREATE TABLE IF NOT EXISTS hg_games (server_id int NOT NULL, id int NOT NULL, winner_uuid varchar(100), win_datetime datetime)");
+				statementCreate.executeUpdate("CREATE TABLE IF NOT EXISTS played_hg_games (server_id int NOT NULL, id int NOT NULL, player_uuid varchar(100))");
+				statementCreate.executeUpdate("CREATE TABLE IF NOT EXISTS players (uuid varchar(100), name varchar(100))");
+				statementCreate.executeUpdate("CREATE OR REPLACE"
+											+ " ALGORITHM = UNDEFINED VIEW `hunger_games`.`v_Scoreboard` AS ("
+											+ " select"
+											+ "     `hunger_games`.`players`.`name` AS `name`,"
+											+ "     count(`hunger_games`.`hg_games`.`winner_uuid`) AS `wins_count`"
+											+ " from"
+											+ "     (`hunger_games`.`hg_games`"
+											+ " join `hunger_games`.`players` on"
+											+ "     ((`hunger_games`.`players`.`uuid` = `hunger_games`.`hg_games`.`winner_uuid`)))"
+											+ " group by"
+											+ "     `hunger_games`.`hg_games`.`winner_uuid`);");
+				statementCreate.close();
 			} catch (SQLException e) {
 				e.printStackTrace();
 			}
@@ -123,7 +139,10 @@ public static int createHGGame(int ServerId){
 					hgGameId = foundRows + 1;
 				}
 				statementInsert.executeUpdate(String.format("INSERT INTO hg_games (server_id, id) VALUES (%d, %d);", ServerId, hgGameId));
-
+
+				statementRead.close();
+				statementInsert.close();
+
 				return hgGameId;
 			} catch (SQLException e) {
 				e.printStackTrace();
@@ -143,6 +162,7 @@ public static void saveStartingDateTime(int ServerId, int HGGameId) {
 			try {
 				Statement statementUpdate = dbConnection.createStatement();
 				statementUpdate.executeUpdate(String.format("UPDATE hg_games SET game_start_datetime = NOW() WHERE server_id = %d AND id = %d;", ServerId, HGGameId));
+				statementUpdate.close();
 			} catch (SQLException e) {
 				e.printStackTrace();
 			}
@@ -178,6 +198,8 @@ public static void addPlayerJoin(int ServerId, int HGGameId, Player player) {
 						statementInsert.executeUpdate(String.format("INSERT INTO played_hg_games (server_id, id, player_uuid) VALUES ('%d', '%d', '%s');", ServerId, HGGameId, player.getUniqueId(), player.getName()));
 					}
 				}
+				statementRead.close();
+				statementInsert.close();
 			} catch (SQLException e) {
 				e.printStackTrace();
 			}
@@ -195,6 +217,7 @@ public static void savePlayerWin(int ServerId, int HGGameId, Player player) {
 			try {
 				Statement statementUpdate = dbConnection.createStatement();
 				statementUpdate.executeUpdate(String.format("UPDATE hg_games SET winner_uuid = '%s', win_datetime = NOW() WHERE server_id = %d AND id = %d", player.getUniqueId().toString(), ServerId, HGGameId));
+				statementUpdate.close();
 			} catch (SQLException e) {
 				e.printStackTrace();
 			}
@@ -218,6 +241,8 @@ public static String getLastWinner(int ServerId){
 						winnerUUID = resultSet.getString("winner_uuid");
 					}
 				}
+				statementRead.close();
+
 				return winnerUUID;
 			} catch (SQLException e) {
 				e.printStackTrace();
@@ -242,6 +267,8 @@ public static boolean isPlayerPremium(String playerUUID){
 				while (resultSet.next()) {
 					isPremium = resultSet.getBoolean("premium");
 				}
+				statementRead.close();
+
 				return isPremium;
 			} catch (SQLException e) {
 				e.printStackTrace();
@@ -250,5 +277,56 @@ public static boolean isPlayerPremium(String playerUUID){
 
 		return false;
 	}
+
+	/**
+	 * Get count of match that player has won
+	 * @param playerUUID
+	 * @return Count of match that player has won
+	 */
+	public static int getPlayerWinCount(String playerUUID) {
+		if (isDatabaseEnabled()) {
+			try {
+				Statement statementRead = dbConnection.createStatement();
+				ResultSet resultSet = statementRead.executeQuery(String.format("SELECT COUNT(winner_uuid) AS winCount FROM hg_games WHERE winner_uuid = '%s';", playerUUID));
+				int winCount = 0;
+
+				while (resultSet.next()) {
+					winCount = resultSet.getInt("winCount");
+				}
+				statementRead.close();
+
+				return winCount;
+			} catch (SQLException e) {
+				e.printStackTrace();
+			}
+		}
+
+		return 0;
+	}
+
+	/**
+	 * Get all players win count
+	 * @return Map made up of players names and win count ordered by win count from highest to lowest
+	 */
+	public static Map<String, Integer> getGlobalScoreboard() {
+		Map<String, Integer> result = new HashMap<>();
+		if (isDatabaseEnabled()) {
+			try {
+				Statement statementRead = dbConnection.createStatement();
+				ResultSet resultSet = statementRead.executeQuery("SELECT name, wins_count FROM v_Scoreboard ORDER BY wins_count");
+
+				while (resultSet.next()) {
+					result.put(resultSet.getString("name"), resultSet.getInt("wins_count"));
+				}
+				statementRead.close();
+
+				return result;
+			} catch (SQLException e) {
+				e.printStackTrace();
+			}
+		}
+
+		return result;
+	}
 }