|
5 | 5 | import com.github.elic0de.thejpspit.config.Settings; |
6 | 6 | import com.github.elic0de.thejpspit.player.OfflinePitPlayer; |
7 | 7 | import com.github.elic0de.thejpspit.player.PitPlayer; |
| 8 | +import com.github.elic0de.thejpspit.player.Preferences; |
8 | 9 | import com.zaxxer.hikari.HikariDataSource; |
9 | 10 | import java.io.InputStream; |
| 11 | +import java.nio.charset.StandardCharsets; |
10 | 12 | import java.sql.Connection; |
| 13 | +import java.sql.PreparedStatement; |
| 14 | +import java.sql.ResultSet; |
11 | 15 | import java.sql.SQLException; |
12 | 16 | import java.sql.Statement; |
13 | 17 | import java.util.Map; |
@@ -96,58 +100,228 @@ public void initialize() throws RuntimeException { |
96 | 100 | } |
97 | 101 |
|
98 | 102 | @Override |
99 | | - public void createPitPlayer(Player Player) { |
100 | | - |
| 103 | + public Optional<PitPlayer> getPitPlayer(Player player) { |
| 104 | + return getPitPlayer(player.getUniqueId()); |
101 | 105 | } |
102 | 106 |
|
103 | 107 | @Override |
104 | | - public void createPitPreferences(PitPreferences preferences) { |
| 108 | + public Optional<PitPlayer> getPitPlayer(UUID uuid) { |
| 109 | + try (PreparedStatement statement = getConnection().prepareStatement( |
| 110 | + format(""" |
| 111 | + SELECT `kills`, `streaks`, `bestStreaks`, `deaths`, `rating`, `bestRating`, `xp`, `preferences` |
| 112 | + FROM `%players_table%` |
| 113 | + WHERE `uuid`=?"""))) { |
| 114 | + |
| 115 | + statement.setString(1, uuid.toString()); |
105 | 116 |
|
| 117 | + final ResultSet resultSet = statement.executeQuery(); |
| 118 | + if (resultSet.next()) { |
| 119 | + final String preferences = new String(resultSet.getBytes("preferences"), StandardCharsets.UTF_8); |
| 120 | + return Optional.of(new PitPlayer(Bukkit.getPlayer(uuid), |
| 121 | + resultSet.getLong("kills"), |
| 122 | + resultSet.getLong("streaks"), |
| 123 | + resultSet.getLong("bestStreaks"), |
| 124 | + resultSet.getLong("deaths"), |
| 125 | + resultSet.getDouble("rating"), |
| 126 | + resultSet.getDouble("bestRating"), |
| 127 | + resultSet.getDouble("xp"), |
| 128 | + Optional.of(plugin.getGson().fromJson(preferences, Preferences.class)) |
| 129 | + )); |
| 130 | + } |
| 131 | + } catch (SQLException e) { |
| 132 | + Bukkit.getLogger().log(Level.SEVERE, |
| 133 | + "Failed to fetch a player from uuid from the database", e); |
| 134 | + } |
| 135 | + return Optional.empty(); |
106 | 136 | } |
107 | 137 |
|
108 | 138 | @Override |
109 | | - public Optional<PitPlayer> getPitPlayer(Player player) { |
| 139 | + public Optional<PitPreferences> getPitPreferences() { |
| 140 | + try (PreparedStatement statement = getConnection().prepareStatement(format(""" |
| 141 | + SELECT `preferences` |
| 142 | + FROM `%pit_preferences%` |
| 143 | + """))) { |
| 144 | + final ResultSet resultSet = statement.executeQuery(); |
| 145 | + if (resultSet.next()) { |
| 146 | + final String preferences = new String(resultSet.getBytes("preferences"), StandardCharsets.UTF_8); |
| 147 | + return Optional.of(plugin.getGson().fromJson(preferences, PitPreferences.class)); |
| 148 | + } |
| 149 | + } catch (SQLException e) { |
| 150 | + Bukkit.getLogger().log(Level.SEVERE, "Failed to fetch user data from table by UUID", e); |
| 151 | + } |
110 | 152 | return Optional.empty(); |
111 | 153 | } |
112 | 154 |
|
113 | 155 | @Override |
114 | | - public Optional<PitPlayer> getPitPlayer(UUID uuid) { |
| 156 | + public Optional<OfflinePitPlayer> getOfflinePitPlayer(UUID uuid) { |
| 157 | + try (PreparedStatement statement = getConnection().prepareStatement( |
| 158 | + format(""" |
| 159 | + SELECT `kills`, `streaks`, `bestStreaks`, `deaths`, `rating`, `bestRating`, `xp` |
| 160 | + FROM `%players_table%` |
| 161 | + WHERE `uuid`=?"""))) { |
| 162 | + |
| 163 | + statement.setString(1, uuid.toString()); |
| 164 | + |
| 165 | + final ResultSet resultSet = statement.executeQuery(); |
| 166 | + if (resultSet.next()) { |
| 167 | + return Optional.of(new OfflinePitPlayer(uuid, |
| 168 | + resultSet.getLong("kills"), |
| 169 | + resultSet.getLong("streaks"), |
| 170 | + resultSet.getLong("bestStreaks"), |
| 171 | + resultSet.getLong("deaths"), |
| 172 | + resultSet.getDouble("rating"), |
| 173 | + resultSet.getDouble("bestRating"), |
| 174 | + resultSet.getDouble("xp") |
| 175 | + )); |
| 176 | + } |
| 177 | + } catch (SQLException e) { |
| 178 | + Bukkit.getLogger().log(Level.SEVERE, |
| 179 | + "Failed to fetch a player from uuid from the database", e); |
| 180 | + } |
115 | 181 | return Optional.empty(); |
116 | 182 | } |
117 | 183 |
|
118 | 184 | @Override |
119 | | - public Optional<PitPreferences> getPitPreferences() { |
120 | | - return Optional.empty(); |
| 185 | + public CompletableFuture<Optional<Integer>> getPlayerRanking(PitPlayer player, RankType type) { |
| 186 | + return CompletableFuture.supplyAsync(() -> { |
| 187 | + try { |
| 188 | + String test = """ |
| 189 | + SELECT uuid, rank |
| 190 | + FROM(SELECT `uuid`, |
| 191 | + RANK() |
| 192 | + OVER(ORDER BY %type% DESC) |
| 193 | + AS rank FROM `%players_table%`) |
| 194 | + WHERE `uuid`=?; |
| 195 | + """; |
| 196 | + try (PreparedStatement statement = getConnection().prepareStatement( |
| 197 | + format(test.replaceAll("%type%", type.name().toLowerCase())))) { |
| 198 | + statement.setString(1, player.getUniqueId().toString()); |
| 199 | + |
| 200 | + final ResultSet resultSet = statement.executeQuery(); |
| 201 | + if (resultSet.next()) { |
| 202 | + return Optional.of(resultSet.getInt("rank")); |
| 203 | + } |
| 204 | + } |
| 205 | + } catch (SQLException e) { |
| 206 | + Bukkit.getLogger().log(Level.SEVERE, |
| 207 | + "Failed to fetch a player from uuid from the database", e); |
| 208 | + } |
| 209 | + return Optional.empty(); |
| 210 | + }); |
121 | 211 | } |
122 | 212 |
|
123 | 213 | @Override |
124 | | - public Optional<OfflinePitPlayer> getOfflinePitPlayer(UUID uuid) { |
125 | | - return Optional.empty(); |
| 214 | + public void createPitPlayer(Player player) { |
| 215 | + // Insert new player data into the database |
| 216 | + try { |
| 217 | + try (PreparedStatement statement = getConnection().prepareStatement( |
| 218 | + format(""" |
| 219 | + INSERT INTO `%players_table%` (`uuid`,`username`,`preferences`) |
| 220 | + VALUES (?,?,?);"""))) { |
| 221 | + |
| 222 | + statement.setString(1, player.getUniqueId().toString()); |
| 223 | + statement.setString(2, player.getName()); |
| 224 | + statement.setBytes(3, plugin.getGson().toJson(Preferences.getDefaults()).getBytes(StandardCharsets.UTF_8)); |
| 225 | + statement.executeUpdate(); |
| 226 | + } |
| 227 | + } catch (SQLException e) { |
| 228 | + Bukkit.getLogger().log(Level.SEVERE, |
| 229 | + "Failed to insert a player into the database", e); |
| 230 | + } |
126 | 231 | } |
127 | 232 |
|
128 | 233 | @Override |
129 | | - public CompletableFuture<Optional<Integer>> getPlayerRanking(PitPlayer player, RankType type) { |
130 | | - return null; |
| 234 | + public void createPitPreferences(PitPreferences pitPreferences) { |
| 235 | + try { |
| 236 | + try (PreparedStatement statement = getConnection().prepareStatement( |
| 237 | + format(""" |
| 238 | + INSERT INTO `%pit_preferences%` (`preferences`) |
| 239 | + VALUES (?);"""))) { |
| 240 | + |
| 241 | + statement.setBytes(1, plugin.getGson().toJson(pitPreferences).getBytes(StandardCharsets.UTF_8)); |
| 242 | + statement.executeUpdate(); |
| 243 | + } |
| 244 | + } catch (SQLException e) { |
| 245 | + Bukkit.getLogger().log(Level.SEVERE, |
| 246 | + "Failed to insert a player into the database", e); |
| 247 | + } |
131 | 248 | } |
132 | 249 |
|
133 | 250 | @Override |
134 | 251 | public void updateUserData(PitPlayer player) { |
| 252 | + try { |
| 253 | + try (PreparedStatement statement = getConnection().prepareStatement( |
| 254 | + format(""" |
| 255 | + UPDATE `%players_table%` |
| 256 | + SET `kills`=?, `streaks`=?, `bestStreaks`=?, `deaths`=?, `rating`=?, `bestRating`=?, `xp`=?, `preferences`=? |
| 257 | + WHERE `uuid`=?"""))) { |
135 | 258 |
|
| 259 | + statement.setLong(1, player.getKills()); |
| 260 | + statement.setLong(2, player.getStreaks()); |
| 261 | + statement.setLong(3, player.getBestStreaks()); |
| 262 | + statement.setLong(4, player.getDeaths()); |
| 263 | + statement.setDouble(5, player.getRating()); |
| 264 | + statement.setDouble(6, player.getBestRating()); |
| 265 | + statement.setDouble(7, player.getXp()); |
| 266 | + statement.setBytes(8, plugin.getGson().toJson(player.getPreferences().get()).getBytes(StandardCharsets.UTF_8)); |
| 267 | + statement.setString(9, player.getUniqueId().toString()); |
| 268 | + statement.executeUpdate(); |
| 269 | + } |
| 270 | + |
| 271 | + } catch (SQLException e) { |
| 272 | + Bukkit.getLogger().log(Level.SEVERE, |
| 273 | + "Failed to update user data for " + player.getName() + " on the database", e); |
| 274 | + } |
136 | 275 | } |
137 | 276 |
|
138 | 277 | @Override |
139 | 278 | public void updateUserData(OfflinePitPlayer player) { |
| 279 | + try { |
| 280 | + try (PreparedStatement statement = getConnection().prepareStatement( |
| 281 | + format(""" |
| 282 | + UPDATE `%players_table%` |
| 283 | + SET `kills`=?, `streaks`=?, `deaths`=?, `rating`=?, `xp`=? |
| 284 | + WHERE `uuid`=?"""))) { |
| 285 | + |
| 286 | + statement.setLong(1, player.getKills()); |
| 287 | + statement.setLong(2, player.getStreaks()); |
| 288 | + statement.setLong(3, player.getDeaths()); |
| 289 | + statement.setDouble(4, player.getRating()); |
| 290 | + statement.setDouble(5, player.getXp()); |
| 291 | + statement.setString(6, player.getUniqueId().toString()); |
| 292 | + statement.executeUpdate(); |
| 293 | + } |
140 | 294 |
|
| 295 | + } catch (SQLException e) { |
| 296 | + Bukkit.getLogger().log(Level.SEVERE, |
| 297 | + "Failed to update user data for " + player.getUniqueId().toString() + " on the database", e); |
| 298 | + } |
141 | 299 | } |
142 | 300 |
|
143 | 301 | @Override |
144 | 302 | public void updatePitPreferences(PitPreferences pitPreferences) { |
145 | | - |
| 303 | + try (PreparedStatement statement = getConnection().prepareStatement(format(""" |
| 304 | + UPDATE `%pit_preferences%` |
| 305 | + SET `preferences` = ? |
| 306 | + """))) { |
| 307 | + statement.setBytes(1, plugin.getGson().toJson(pitPreferences).getBytes(StandardCharsets.UTF_8)); |
| 308 | + statement.executeUpdate(); |
| 309 | + } catch (SQLException e) { |
| 310 | + Bukkit.getLogger().log(Level.SEVERE, "Failed to update preferences in table", e); |
| 311 | + } |
146 | 312 | } |
147 | 313 |
|
148 | 314 | @Override |
149 | 315 | public void deletePlayerData() { |
150 | | - |
| 316 | + try (Connection connection = getConnection()) { |
| 317 | + try (PreparedStatement statement = connection.prepareStatement(format(""" |
| 318 | + DELETE FROM `%players_table%` |
| 319 | + """))) { |
| 320 | + statement.executeUpdate(); |
| 321 | + } |
| 322 | + } catch (SQLException e) { |
| 323 | + Bukkit.getLogger().log(Level.SEVERE, "Failed to delete playerData from table", e); |
| 324 | + } |
151 | 325 | } |
152 | 326 |
|
153 | 327 | @Override |
|
0 commit comments