gpatruno
397 lines
16 KiB
Java
397 lines
16 KiB
Java
package com.spaceshipproject;
|
|
|
|
import org.bukkit.entity.Player;
|
|
|
|
import java.io.File;
|
|
import java.sql.*;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.UUID;
|
|
|
|
/**
|
|
* Gestionnaire de la base de données SQLite.
|
|
*
|
|
* Tables :
|
|
* - players(uuid, name, settings, created_at, updated_at)
|
|
* - spaceships(id, owner_uuid, name, size_x/y/z, spawn_x/y/z, schematic, settings, created_at, updated_at)
|
|
* - spaceships_loaded(spaceship_id, world, origin_x/y/z, loaded_at)
|
|
*/
|
|
public class DatabaseManager {
|
|
|
|
private final SpaceShipProject plugin;
|
|
private Connection connection;
|
|
|
|
public DatabaseManager(SpaceShipProject plugin) {
|
|
this.plugin = plugin;
|
|
}
|
|
|
|
public void initialize() {
|
|
try {
|
|
File dataFolder = plugin.getDataFolder();
|
|
if (!dataFolder.exists()) {
|
|
dataFolder.mkdirs();
|
|
}
|
|
File dbFile = new File(dataFolder, "spaceships.db");
|
|
connection = DriverManager.getConnection("jdbc:sqlite:" + dbFile.getAbsolutePath());
|
|
try (Statement stmt = connection.createStatement()) {
|
|
stmt.execute("PRAGMA foreign_keys = ON;");
|
|
}
|
|
createTables();
|
|
plugin.getLogger().info("Base de donnees SpaceShipProject initialisee.");
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur a l'initialisation de la base : " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
public void close() {
|
|
try {
|
|
if (connection != null && !connection.isClosed()) {
|
|
connection.close();
|
|
}
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur a la fermeture de la base : " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
private void createTables() throws SQLException {
|
|
String players = """
|
|
CREATE TABLE IF NOT EXISTS players (
|
|
uuid TEXT PRIMARY KEY,
|
|
name TEXT,
|
|
settings TEXT,
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
|
)
|
|
""";
|
|
String spaceships = """
|
|
CREATE TABLE IF NOT EXISTS spaceships (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
owner_uuid TEXT NOT NULL,
|
|
name TEXT NOT NULL,
|
|
size_x INTEGER NOT NULL,
|
|
size_y INTEGER NOT NULL,
|
|
size_z INTEGER NOT NULL,
|
|
spawn_x INTEGER NOT NULL,
|
|
spawn_y INTEGER NOT NULL,
|
|
spawn_z INTEGER NOT NULL,
|
|
schematic TEXT,
|
|
settings TEXT,
|
|
level INTEGER NOT NULL DEFAULT 1,
|
|
money INTEGER NOT NULL DEFAULT 0,
|
|
last_loaded_level INTEGER NOT NULL DEFAULT 1,
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
FOREIGN KEY (owner_uuid) REFERENCES players(uuid) ON DELETE CASCADE
|
|
)
|
|
""";
|
|
String loaded = """
|
|
CREATE TABLE IF NOT EXISTS spaceships_loaded (
|
|
spaceship_id INTEGER PRIMARY KEY,
|
|
world TEXT NOT NULL,
|
|
origin_x INTEGER NOT NULL,
|
|
origin_y INTEGER NOT NULL,
|
|
origin_z INTEGER NOT NULL,
|
|
loaded_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
FOREIGN KEY (spaceship_id) REFERENCES spaceships(id) ON DELETE CASCADE
|
|
)
|
|
""";
|
|
try (Statement stmt = connection.createStatement()) {
|
|
stmt.execute(players);
|
|
stmt.execute(spaceships);
|
|
stmt.execute(loaded);
|
|
// Migrations (idempotentes) pour les bases creees avant l'ajout de level/money.
|
|
tryAlter(stmt, "ALTER TABLE spaceships ADD COLUMN level INTEGER NOT NULL DEFAULT 1");
|
|
tryAlter(stmt, "ALTER TABLE spaceships ADD COLUMN money INTEGER NOT NULL DEFAULT 0");
|
|
tryAlter(stmt, "ALTER TABLE spaceships ADD COLUMN last_loaded_level INTEGER NOT NULL DEFAULT 1");
|
|
}
|
|
}
|
|
|
|
private void tryAlter(Statement stmt, String sql) {
|
|
try { stmt.execute(sql); } catch (SQLException ignored) { /* colonne deja presente */ }
|
|
}
|
|
|
|
/* ========================= PLAYERS ========================= */
|
|
|
|
public void upsertPlayer(Player player) {
|
|
String sql = """
|
|
INSERT INTO players(uuid, name, updated_at)
|
|
VALUES(?, ?, CURRENT_TIMESTAMP)
|
|
ON CONFLICT(uuid) DO UPDATE SET name = excluded.name, updated_at = CURRENT_TIMESTAMP
|
|
""";
|
|
try (PreparedStatement stmt = connection.prepareStatement(sql)) {
|
|
stmt.setString(1, player.getUniqueId().toString());
|
|
stmt.setString(2, player.getName());
|
|
stmt.executeUpdate();
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur upsertPlayer : " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
public void setPlayerSettings(UUID uuid, String settingsJson) {
|
|
String sql = "UPDATE players SET settings = ?, updated_at = CURRENT_TIMESTAMP WHERE uuid = ?";
|
|
try (PreparedStatement stmt = connection.prepareStatement(sql)) {
|
|
stmt.setString(1, settingsJson);
|
|
stmt.setString(2, uuid.toString());
|
|
stmt.executeUpdate();
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur setPlayerSettings : " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
public String getPlayerSettings(UUID uuid) {
|
|
String sql = "SELECT settings FROM players WHERE uuid = ?";
|
|
try (PreparedStatement stmt = connection.prepareStatement(sql)) {
|
|
stmt.setString(1, uuid.toString());
|
|
try (ResultSet rs = stmt.executeQuery()) {
|
|
if (rs.next()) return rs.getString("settings");
|
|
}
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur getPlayerSettings : " + e.getMessage());
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/* ========================= SPACESHIPS ========================= */
|
|
|
|
public long createSpaceship(UUID owner, String name,
|
|
int sizeX, int sizeY, int sizeZ,
|
|
int spawnX, int spawnY, int spawnZ,
|
|
String schematicJson, String settingsJson) {
|
|
String sql = """
|
|
INSERT INTO spaceships(owner_uuid, name, size_x, size_y, size_z,
|
|
spawn_x, spawn_y, spawn_z, schematic, settings, level, money, last_loaded_level)
|
|
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, 0, 1)
|
|
""";
|
|
try (PreparedStatement stmt = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
|
|
stmt.setString(1, owner.toString());
|
|
stmt.setString(2, name);
|
|
stmt.setInt(3, sizeX);
|
|
stmt.setInt(4, sizeY);
|
|
stmt.setInt(5, sizeZ);
|
|
stmt.setInt(6, spawnX);
|
|
stmt.setInt(7, spawnY);
|
|
stmt.setInt(8, spawnZ);
|
|
stmt.setString(9, schematicJson);
|
|
stmt.setString(10, settingsJson);
|
|
stmt.executeUpdate();
|
|
try (ResultSet keys = stmt.getGeneratedKeys()) {
|
|
if (keys.next()) return keys.getLong(1);
|
|
}
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur createSpaceship : " + e.getMessage());
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public Spaceship getSpaceship(long id) {
|
|
String sql = "SELECT * FROM spaceships WHERE id = ?";
|
|
try (PreparedStatement stmt = connection.prepareStatement(sql)) {
|
|
stmt.setLong(1, id);
|
|
try (ResultSet rs = stmt.executeQuery()) {
|
|
if (rs.next()) return rowToSpaceship(rs);
|
|
}
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur getSpaceship : " + e.getMessage());
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public List<Spaceship> getSpaceshipsByOwner(UUID owner) {
|
|
List<Spaceship> list = new ArrayList<>();
|
|
String sql = "SELECT * FROM spaceships WHERE owner_uuid = ? ORDER BY id ASC";
|
|
try (PreparedStatement stmt = connection.prepareStatement(sql)) {
|
|
stmt.setString(1, owner.toString());
|
|
try (ResultSet rs = stmt.executeQuery()) {
|
|
while (rs.next()) list.add(rowToSpaceship(rs));
|
|
}
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur getSpaceshipsByOwner : " + e.getMessage());
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public int countSpaceshipsByOwner(UUID owner) {
|
|
String sql = "SELECT COUNT(*) FROM spaceships WHERE owner_uuid = ?";
|
|
try (PreparedStatement stmt = connection.prepareStatement(sql)) {
|
|
stmt.setString(1, owner.toString());
|
|
try (ResultSet rs = stmt.executeQuery()) {
|
|
if (rs.next()) return rs.getInt(1);
|
|
}
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur countSpaceshipsByOwner : " + e.getMessage());
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
@SuppressWarnings("deprecation")
|
|
public void updateSpaceship(Spaceship ship) {
|
|
String sql = """
|
|
UPDATE spaceships SET
|
|
name = ?, size_x = ?, size_y = ?, size_z = ?,
|
|
spawn_x = ?, spawn_y = ?, spawn_z = ?,
|
|
schematic = ?, settings = ?, level = ?, money = ?, last_loaded_level = ?,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE id = ?
|
|
""";
|
|
try (PreparedStatement stmt = connection.prepareStatement(sql)) {
|
|
stmt.setString(1, ship.getName());
|
|
stmt.setInt(2, ship.getSizeX());
|
|
stmt.setInt(3, ship.getSizeY());
|
|
stmt.setInt(4, ship.getSizeZ());
|
|
stmt.setInt(5, ship.getSpawnX());
|
|
stmt.setInt(6, ship.getSpawnY());
|
|
stmt.setInt(7, ship.getSpawnZ());
|
|
stmt.setString(8, ship.getSchematicJson());
|
|
stmt.setString(9, ship.getSettingsJson());
|
|
stmt.setInt(10, ship.getLevel());
|
|
stmt.setInt(11, ship.getMoney());
|
|
stmt.setInt(12, ship.getLastLoadedLevel());
|
|
stmt.setLong(13, ship.getId());
|
|
stmt.executeUpdate();
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur updateSpaceship : " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
public void deleteSpaceship(long id) {
|
|
try (PreparedStatement st1 = connection.prepareStatement("DELETE FROM spaceships_loaded WHERE spaceship_id = ?");
|
|
PreparedStatement st2 = connection.prepareStatement("DELETE FROM spaceships WHERE id = ?")) {
|
|
st1.setLong(1, id);
|
|
st1.executeUpdate();
|
|
st2.setLong(1, id);
|
|
st2.executeUpdate();
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur deleteSpaceship : " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
private Spaceship rowToSpaceship(ResultSet rs) throws SQLException {
|
|
int level = 1, money = 0, lastLoadedLevel = 1;
|
|
try { level = rs.getInt("level"); if (rs.wasNull()) level = 1; } catch (SQLException ignored) {}
|
|
try { money = rs.getInt("money"); } catch (SQLException ignored) {}
|
|
try { lastLoadedLevel = rs.getInt("last_loaded_level"); if (rs.wasNull()) lastLoadedLevel = 1; } catch (SQLException ignored) {}
|
|
return new Spaceship(
|
|
rs.getLong("id"),
|
|
UUID.fromString(rs.getString("owner_uuid")),
|
|
rs.getString("name"),
|
|
rs.getInt("size_x"), rs.getInt("size_y"), rs.getInt("size_z"),
|
|
rs.getInt("spawn_x"), rs.getInt("spawn_y"), rs.getInt("spawn_z"),
|
|
rs.getString("schematic"),
|
|
rs.getString("settings"),
|
|
level, money, lastLoadedLevel
|
|
);
|
|
}
|
|
|
|
/* ========================= SPACESHIPS_LOADED ========================= */
|
|
|
|
public void markLoaded(long spaceshipId, String world, int x, int y, int z) {
|
|
String sql = """
|
|
INSERT INTO spaceships_loaded(spaceship_id, world, origin_x, origin_y, origin_z, loaded_at)
|
|
VALUES(?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
|
|
ON CONFLICT(spaceship_id) DO UPDATE SET
|
|
world = excluded.world,
|
|
origin_x = excluded.origin_x,
|
|
origin_y = excluded.origin_y,
|
|
origin_z = excluded.origin_z,
|
|
loaded_at = CURRENT_TIMESTAMP
|
|
""";
|
|
try (PreparedStatement stmt = connection.prepareStatement(sql)) {
|
|
stmt.setLong(1, spaceshipId);
|
|
stmt.setString(2, world);
|
|
stmt.setInt(3, x);
|
|
stmt.setInt(4, y);
|
|
stmt.setInt(5, z);
|
|
stmt.executeUpdate();
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur markLoaded : " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
public void markUnloaded(long spaceshipId) {
|
|
String sql = "DELETE FROM spaceships_loaded WHERE spaceship_id = ?";
|
|
try (PreparedStatement stmt = connection.prepareStatement(sql)) {
|
|
stmt.setLong(1, spaceshipId);
|
|
stmt.executeUpdate();
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur markUnloaded : " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
public LoadedSpaceship getLoaded(long spaceshipId) {
|
|
String sql = """
|
|
SELECT l.spaceship_id, l.world, l.origin_x, l.origin_y, l.origin_z,
|
|
s.size_x, s.size_y, s.size_z
|
|
FROM spaceships_loaded l
|
|
JOIN spaceships s ON s.id = l.spaceship_id
|
|
WHERE l.spaceship_id = ?
|
|
""";
|
|
try (PreparedStatement stmt = connection.prepareStatement(sql)) {
|
|
stmt.setLong(1, spaceshipId);
|
|
try (ResultSet rs = stmt.executeQuery()) {
|
|
if (rs.next()) {
|
|
return new LoadedSpaceship(
|
|
rs.getLong("spaceship_id"),
|
|
rs.getString("world"),
|
|
rs.getInt("origin_x"), rs.getInt("origin_y"), rs.getInt("origin_z"),
|
|
rs.getInt("size_x"), rs.getInt("size_y"), rs.getInt("size_z")
|
|
);
|
|
}
|
|
}
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur getLoaded : " + e.getMessage());
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public List<LoadedSpaceship> getLoadedByOwner(UUID owner) {
|
|
List<LoadedSpaceship> list = new ArrayList<>();
|
|
String sql = """
|
|
SELECT l.spaceship_id, l.world, l.origin_x, l.origin_y, l.origin_z,
|
|
s.size_x, s.size_y, s.size_z
|
|
FROM spaceships_loaded l
|
|
JOIN spaceships s ON s.id = l.spaceship_id
|
|
WHERE s.owner_uuid = ?
|
|
""";
|
|
try (PreparedStatement stmt = connection.prepareStatement(sql)) {
|
|
stmt.setString(1, owner.toString());
|
|
try (ResultSet rs = stmt.executeQuery()) {
|
|
while (rs.next()) {
|
|
list.add(new LoadedSpaceship(
|
|
rs.getLong("spaceship_id"),
|
|
rs.getString("world"),
|
|
rs.getInt("origin_x"), rs.getInt("origin_y"), rs.getInt("origin_z"),
|
|
rs.getInt("size_x"), rs.getInt("size_y"), rs.getInt("size_z")
|
|
));
|
|
}
|
|
}
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur getLoadedByOwner : " + e.getMessage());
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public List<LoadedSpaceship> getAllLoaded() {
|
|
List<LoadedSpaceship> list = new ArrayList<>();
|
|
String sql = """
|
|
SELECT l.spaceship_id, l.world, l.origin_x, l.origin_y, l.origin_z,
|
|
s.size_x, s.size_y, s.size_z
|
|
FROM spaceships_loaded l
|
|
JOIN spaceships s ON s.id = l.spaceship_id
|
|
""";
|
|
try (PreparedStatement stmt = connection.prepareStatement(sql);
|
|
ResultSet rs = stmt.executeQuery()) {
|
|
while (rs.next()) {
|
|
list.add(new LoadedSpaceship(
|
|
rs.getLong("spaceship_id"),
|
|
rs.getString("world"),
|
|
rs.getInt("origin_x"), rs.getInt("origin_y"), rs.getInt("origin_z"),
|
|
rs.getInt("size_x"), rs.getInt("size_y"), rs.getInt("size_z")
|
|
));
|
|
}
|
|
} catch (SQLException e) {
|
|
plugin.getLogger().severe("Erreur getAllLoaded : " + e.getMessage());
|
|
}
|
|
return list;
|
|
}
|
|
}
|