775 lines
29 KiB
Java
775 lines
29 KiB
Java
/*
|
|
GriefPrevention Server Plugin for Minecraft
|
|
Copyright (C) 2012 Ryan Hamshire
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package me.ryanhamshire.GriefPrevention;
|
|
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.Location;
|
|
import org.bukkit.OfflinePlayer;
|
|
import org.bukkit.World;
|
|
|
|
import java.io.PrintWriter;
|
|
import java.io.StringWriter;
|
|
import java.sql.Connection;
|
|
import java.sql.DriverManager;
|
|
import java.sql.PreparedStatement;
|
|
import java.sql.ResultSet;
|
|
import java.sql.SQLException;
|
|
import java.sql.Statement;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Properties;
|
|
import java.util.UUID;
|
|
|
|
//manages data stored in the file system
|
|
public class DatabaseDataStore extends DataStore
|
|
{
|
|
private Connection databaseConnection = null;
|
|
|
|
private String databaseUrl;
|
|
private String userName;
|
|
private String password;
|
|
|
|
private String updateNameSQL;
|
|
private String insertClaimSQL;
|
|
private String deleteClaimSQL;
|
|
private String getPlayerDataSQL;
|
|
private String deletePlayerDataSQL;
|
|
private String insertPlayerDataSQL;
|
|
private String insertNextClaimIdSQL;
|
|
private String deleteGroupBonusSQL;
|
|
private String insertSchemaVerSQL;
|
|
private String deleteNextClaimIdSQL;
|
|
private String deleteSchemaVersionSQL;
|
|
private String selectSchemaVersionSQL;
|
|
|
|
DatabaseDataStore(String url, String userName, String password) throws Exception
|
|
{
|
|
this.databaseUrl = url;
|
|
this.userName = userName;
|
|
this.password = password;
|
|
|
|
this.initialize();
|
|
}
|
|
|
|
@Override
|
|
void initialize() throws Exception
|
|
{
|
|
try
|
|
{
|
|
//load the java driver for mySQL
|
|
Class.forName("com.mysql.jdbc.Driver");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
GriefPrevention.AddLogEntry("ERROR: Unable to load Java's mySQL database driver. Check to make sure you've installed it properly.");
|
|
throw e;
|
|
}
|
|
|
|
try
|
|
{
|
|
this.refreshDataConnection();
|
|
}
|
|
catch (Exception e2)
|
|
{
|
|
GriefPrevention.AddLogEntry("ERROR: Unable to connect to database. Check your config file settings.");
|
|
throw e2;
|
|
}
|
|
|
|
try
|
|
{
|
|
//ensure the data tables exist
|
|
Statement statement = databaseConnection.createStatement();
|
|
|
|
statement.execute("CREATE TABLE IF NOT EXISTS griefprevention_nextclaimid (nextid INT(15));");
|
|
|
|
statement.execute("CREATE TABLE IF NOT EXISTS griefprevention_claimdata (id INT(15), owner VARCHAR(50), lessercorner VARCHAR(100), greatercorner VARCHAR(100), builders TEXT, containers TEXT, accessors TEXT, managers TEXT, inheritnothing BOOLEAN, parentid INT(15));");
|
|
|
|
statement.execute("CREATE TABLE IF NOT EXISTS griefprevention_playerdata (name VARCHAR(50), lastlogin DATETIME, accruedblocks INT(15), bonusblocks INT(15));");
|
|
|
|
statement.execute("CREATE TABLE IF NOT EXISTS griefprevention_schemaversion (version INT(15));");
|
|
|
|
statement.execute("ALTER TABLE griefprevention_claimdata MODIFY builders TEXT;");
|
|
statement.execute("ALTER TABLE griefprevention_claimdata MODIFY containers TEXT;");
|
|
statement.execute("ALTER TABLE griefprevention_claimdata MODIFY accessors TEXT;");
|
|
statement.execute("ALTER TABLE griefprevention_claimdata MODIFY managers TEXT;");
|
|
|
|
//if the next claim id table is empty, this is a brand new database which will write using the latest schema
|
|
//otherwise, schema version is determined by schemaversion table (or =0 if table is empty, see getSchemaVersion())
|
|
ResultSet results = statement.executeQuery("SELECT * FROM griefprevention_nextclaimid;");
|
|
if (!results.next())
|
|
{
|
|
this.setSchemaVersion(latestSchemaVersion);
|
|
}
|
|
}
|
|
catch (Exception e3)
|
|
{
|
|
GriefPrevention.AddLogEntry("ERROR: Unable to create the necessary database table. Details:");
|
|
GriefPrevention.AddLogEntry(e3.getMessage());
|
|
e3.printStackTrace();
|
|
throw e3;
|
|
}
|
|
|
|
this.updateNameSQL = "UPDATE griefprevention_playerdata SET name = ? WHERE name = ?;";
|
|
this.insertClaimSQL = "INSERT INTO griefprevention_claimdata (id, owner, lessercorner, greatercorner, builders, containers, accessors, managers, inheritnothing, parentid) VALUES(?,?,?,?,?,?,?,?,?,?);";
|
|
this.deleteClaimSQL = "DELETE FROM griefprevention_claimdata WHERE id=?;";
|
|
this.getPlayerDataSQL = "SELECT * FROM griefprevention_playerdata WHERE name=?;";
|
|
this.deletePlayerDataSQL = "DELETE FROM griefprevention_playerdata WHERE name=?;";
|
|
this.insertPlayerDataSQL = "INSERT INTO griefprevention_playerdata (name, lastlogin, accruedblocks, bonusblocks) VALUES (?,?,?,?);";
|
|
this.insertNextClaimIdSQL = "INSERT INTO griefprevention_nextclaimid VALUES (?);";
|
|
this.deleteGroupBonusSQL = "DELETE FROM griefprevention_playerdata WHERE name=?;";
|
|
this.insertSchemaVerSQL = "INSERT INTO griefprevention_schemaversion VALUES (?)";
|
|
this.deleteNextClaimIdSQL = "DELETE FROM griefprevention_nextclaimid;";
|
|
this.deleteSchemaVersionSQL = "DELETE FROM griefprevention_schemaversion;";
|
|
this.selectSchemaVersionSQL = "SELECT * FROM griefprevention_schemaversion;";
|
|
|
|
//load group data into memory
|
|
Statement statement = databaseConnection.createStatement();
|
|
ResultSet results = statement.executeQuery("SELECT * FROM griefprevention_playerdata;");
|
|
|
|
while (results.next())
|
|
{
|
|
String name = results.getString("name");
|
|
|
|
//ignore non-groups. all group names start with a dollar sign.
|
|
if (!name.startsWith("$")) continue;
|
|
|
|
String groupName = name.substring(1);
|
|
if (groupName == null || groupName.isEmpty()) continue; //defensive coding, avoid unlikely cases
|
|
|
|
int groupBonusBlocks = results.getInt("bonusblocks");
|
|
|
|
this.permissionToBonusBlocksMap.put(groupName, groupBonusBlocks);
|
|
}
|
|
|
|
//load next claim number into memory
|
|
results = statement.executeQuery("SELECT * FROM griefprevention_nextclaimid;");
|
|
|
|
//if there's nothing yet, add it
|
|
if (!results.next())
|
|
{
|
|
statement.execute("INSERT INTO griefprevention_nextclaimid VALUES(0);");
|
|
this.nextClaimID = (long) 0;
|
|
}
|
|
|
|
//otherwise load it
|
|
else
|
|
{
|
|
this.nextClaimID = results.getLong("nextid");
|
|
}
|
|
|
|
if (this.getSchemaVersion() == 0)
|
|
{
|
|
try
|
|
{
|
|
this.refreshDataConnection();
|
|
|
|
//pull ALL player data from the database
|
|
statement = this.databaseConnection.createStatement();
|
|
results = statement.executeQuery("SELECT * FROM griefprevention_playerdata;");
|
|
|
|
//make a list of changes to be made
|
|
HashMap<String, UUID> changes = new HashMap<String, UUID>();
|
|
|
|
ArrayList<String> namesToConvert = new ArrayList<String>();
|
|
while (results.next())
|
|
{
|
|
//get the id
|
|
String playerName = results.getString("name");
|
|
|
|
//add to list of names to convert to UUID
|
|
namesToConvert.add(playerName);
|
|
}
|
|
|
|
//resolve and cache as many as possible through various means
|
|
try
|
|
{
|
|
UUIDFetcher fetcher = new UUIDFetcher(namesToConvert);
|
|
fetcher.call();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
GriefPrevention.AddLogEntry("Failed to resolve a batch of names to UUIDs. Details:" + e.getMessage());
|
|
e.printStackTrace();
|
|
}
|
|
|
|
//reset results cursor
|
|
results.beforeFirst();
|
|
|
|
//for each result
|
|
while (results.next())
|
|
{
|
|
//get the id
|
|
String playerName = results.getString("name");
|
|
|
|
//try to convert player name to UUID
|
|
try
|
|
{
|
|
UUID playerID = UUIDFetcher.getUUIDOf(playerName);
|
|
|
|
//if successful, update the playerdata row by replacing the player's name with the player's UUID
|
|
if (playerID != null)
|
|
{
|
|
changes.put(playerName, playerID);
|
|
}
|
|
}
|
|
//otherwise leave it as-is. no harm done - it won't be requested by name, and this update only happens once.
|
|
catch (Exception ex) { }
|
|
}
|
|
|
|
//refresh data connection in case data migration took a long time
|
|
this.refreshDataConnection();
|
|
|
|
for (String name : changes.keySet())
|
|
{
|
|
try (PreparedStatement updateStmnt = this.databaseConnection.prepareStatement(this.getUpdateNameSQL()))
|
|
{
|
|
updateStmnt.setString(1, changes.get(name).toString());
|
|
updateStmnt.setString(2, name);
|
|
updateStmnt.executeUpdate();
|
|
}
|
|
catch (SQLException e)
|
|
{
|
|
GriefPrevention.AddLogEntry("Unable to convert player data for " + name + ". Skipping.");
|
|
GriefPrevention.AddLogEntry(e.getMessage());
|
|
}
|
|
}
|
|
}
|
|
catch (SQLException e)
|
|
{
|
|
GriefPrevention.AddLogEntry("Unable to convert player data. Details:");
|
|
GriefPrevention.AddLogEntry(e.getMessage());
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
if (this.getSchemaVersion() <= 2)
|
|
{
|
|
statement = this.databaseConnection.createStatement();
|
|
statement.execute("ALTER TABLE griefprevention_claimdata ADD inheritNothing BOOLEAN DEFAULT 0 AFTER managers;");
|
|
}
|
|
|
|
//load claims data into memory
|
|
|
|
results = statement.executeQuery("SELECT * FROM griefprevention_claimdata;");
|
|
|
|
ArrayList<Claim> claimsToRemove = new ArrayList<Claim>();
|
|
ArrayList<Claim> subdivisionsToLoad = new ArrayList<Claim>();
|
|
List<World> validWorlds = Bukkit.getServer().getWorlds();
|
|
|
|
Long claimID = null;
|
|
while (results.next())
|
|
{
|
|
try
|
|
{
|
|
//problematic claims will be removed from secondary storage, and never added to in-memory data store
|
|
boolean removeClaim = false;
|
|
|
|
long parentId = results.getLong("parentid");
|
|
claimID = results.getLong("id");
|
|
boolean inheritNothing = results.getBoolean("inheritNothing");
|
|
Location lesserBoundaryCorner = null;
|
|
Location greaterBoundaryCorner = null;
|
|
String lesserCornerString = "(location not available)";
|
|
try
|
|
{
|
|
lesserCornerString = results.getString("lessercorner");
|
|
lesserBoundaryCorner = this.locationFromString(lesserCornerString, validWorlds);
|
|
String greaterCornerString = results.getString("greatercorner");
|
|
greaterBoundaryCorner = this.locationFromString(greaterCornerString, validWorlds);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (e.getMessage() != null && e.getMessage().contains("World not found"))
|
|
{
|
|
GriefPrevention.AddLogEntry("Failed to load a claim (ID:" + claimID.toString() + ") because its world isn't loaded (yet?). Please delete the claim or contact the GriefPrevention developer with information about which plugin(s) you're using to load or create worlds. " + lesserCornerString);
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
String ownerName = results.getString("owner");
|
|
UUID ownerID = null;
|
|
if (ownerName.isEmpty() || ownerName.startsWith("--"))
|
|
{
|
|
ownerID = null; //administrative land claim or subdivision
|
|
}
|
|
else if (this.getSchemaVersion() < 1)
|
|
{
|
|
try
|
|
{
|
|
ownerID = UUIDFetcher.getUUIDOf(ownerName);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
GriefPrevention.AddLogEntry("This owner name did not convert to a UUID: " + ownerName + ".");
|
|
GriefPrevention.AddLogEntry(" Converted land claim to administrative @ " + lesserBoundaryCorner.toString());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
ownerID = UUID.fromString(ownerName);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
GriefPrevention.AddLogEntry("This owner entry is not a UUID: " + ownerName + ".");
|
|
GriefPrevention.AddLogEntry(" Converted land claim to administrative @ " + lesserBoundaryCorner.toString());
|
|
}
|
|
}
|
|
|
|
String buildersString = results.getString("builders");
|
|
List<String> builderNames = Arrays.asList(buildersString.split(";"));
|
|
builderNames = this.convertNameListToUUIDList(builderNames);
|
|
|
|
String containersString = results.getString("containers");
|
|
List<String> containerNames = Arrays.asList(containersString.split(";"));
|
|
containerNames = this.convertNameListToUUIDList(containerNames);
|
|
|
|
String accessorsString = results.getString("accessors");
|
|
List<String> accessorNames = Arrays.asList(accessorsString.split(";"));
|
|
accessorNames = this.convertNameListToUUIDList(accessorNames);
|
|
|
|
String managersString = results.getString("managers");
|
|
List<String> managerNames = Arrays.asList(managersString.split(";"));
|
|
managerNames = this.convertNameListToUUIDList(managerNames);
|
|
Claim claim = new Claim(lesserBoundaryCorner, greaterBoundaryCorner, ownerID, builderNames, containerNames, accessorNames, managerNames, inheritNothing, claimID);
|
|
|
|
if (removeClaim)
|
|
{
|
|
claimsToRemove.add(claim);
|
|
}
|
|
else if (parentId == -1)
|
|
{
|
|
//top level claim
|
|
this.addClaim(claim, false);
|
|
}
|
|
else
|
|
{
|
|
//subdivision
|
|
subdivisionsToLoad.add(claim);
|
|
}
|
|
}
|
|
catch (SQLException e)
|
|
{
|
|
GriefPrevention.AddLogEntry("Unable to load a claim. Details: " + e.getMessage() + " ... " + results.toString());
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
//add subdivisions to their parent claims
|
|
for (Claim childClaim : subdivisionsToLoad)
|
|
{
|
|
//find top level claim parent
|
|
Claim topLevelClaim = this.getClaimAt(childClaim.getLesserBoundaryCorner(), true, null);
|
|
|
|
if (topLevelClaim == null)
|
|
{
|
|
claimsToRemove.add(childClaim);
|
|
GriefPrevention.AddLogEntry("Removing orphaned claim subdivision: " + childClaim.getLesserBoundaryCorner().toString());
|
|
continue;
|
|
}
|
|
|
|
//add this claim to the list of children of the current top level claim
|
|
childClaim.parent = topLevelClaim;
|
|
topLevelClaim.children.add(childClaim);
|
|
childClaim.inDataStore = true;
|
|
}
|
|
|
|
for (Claim claim : claimsToRemove)
|
|
{
|
|
this.deleteClaimFromSecondaryStorage(claim);
|
|
}
|
|
|
|
if (this.getSchemaVersion() <= 2)
|
|
{
|
|
this.refreshDataConnection();
|
|
statement = this.databaseConnection.createStatement();
|
|
statement.execute("DELETE FROM griefprevention_claimdata WHERE id='-1';");
|
|
}
|
|
|
|
super.initialize();
|
|
}
|
|
|
|
@Override
|
|
synchronized void writeClaimToStorage(Claim claim) //see datastore.cs. this will ALWAYS be a top level claim
|
|
{
|
|
try
|
|
{
|
|
this.refreshDataConnection();
|
|
|
|
//wipe out any existing data about this claim
|
|
this.deleteClaimFromSecondaryStorage(claim);
|
|
|
|
//write claim data to the database
|
|
this.writeClaimData(claim);
|
|
}
|
|
catch (SQLException e)
|
|
{
|
|
GriefPrevention.AddLogEntry("Unable to save data for claim at " + this.locationToString(claim.lesserBoundaryCorner) + ". Details:");
|
|
GriefPrevention.AddLogEntry(e.getMessage());
|
|
}
|
|
}
|
|
|
|
//actually writes claim data to the database
|
|
synchronized private void writeClaimData(Claim claim) throws SQLException
|
|
{
|
|
String lesserCornerString = this.locationToString(claim.getLesserBoundaryCorner());
|
|
String greaterCornerString = this.locationToString(claim.getGreaterBoundaryCorner());
|
|
String owner = "";
|
|
if (claim.ownerID != null) owner = claim.ownerID.toString();
|
|
|
|
ArrayList<String> builders = new ArrayList<String>();
|
|
ArrayList<String> containers = new ArrayList<String>();
|
|
ArrayList<String> accessors = new ArrayList<String>();
|
|
ArrayList<String> managers = new ArrayList<String>();
|
|
|
|
claim.getPermissions(builders, containers, accessors, managers);
|
|
|
|
String buildersString = this.storageStringBuilder(builders);
|
|
String containersString = this.storageStringBuilder(containers);
|
|
String accessorsString = this.storageStringBuilder(accessors);
|
|
String managersString = this.storageStringBuilder(managers);
|
|
boolean inheritNothing = claim.getSubclaimRestrictions();
|
|
long parentId = claim.parent == null ? -1 : claim.parent.id;
|
|
|
|
try (PreparedStatement insertStmt = this.databaseConnection.prepareStatement(this.getInsertClaimSQL()))
|
|
{
|
|
|
|
insertStmt.setLong(1, claim.id);
|
|
insertStmt.setString(2, owner);
|
|
insertStmt.setString(3, lesserCornerString);
|
|
insertStmt.setString(4, greaterCornerString);
|
|
insertStmt.setString(5, buildersString);
|
|
insertStmt.setString(6, containersString);
|
|
insertStmt.setString(7, accessorsString);
|
|
insertStmt.setString(8, managersString);
|
|
insertStmt.setBoolean(9, inheritNothing);
|
|
insertStmt.setLong(10, parentId);
|
|
insertStmt.executeUpdate();
|
|
}
|
|
catch (SQLException e)
|
|
{
|
|
GriefPrevention.AddLogEntry("Unable to save data for claim at " + this.locationToString(claim.lesserBoundaryCorner) + ". Details:");
|
|
GriefPrevention.AddLogEntry(e.getMessage());
|
|
}
|
|
}
|
|
|
|
//deletes a claim from the database
|
|
@Override
|
|
synchronized void deleteClaimFromSecondaryStorage(Claim claim)
|
|
{
|
|
try (PreparedStatement deleteStmnt = this.databaseConnection.prepareStatement(this.getDeleteClaimSQL()))
|
|
{
|
|
deleteStmnt.setLong(1, claim.id);
|
|
deleteStmnt.executeUpdate();
|
|
}
|
|
catch (SQLException e)
|
|
{
|
|
GriefPrevention.AddLogEntry("Unable to delete data for claim " + claim.id + ". Details:");
|
|
GriefPrevention.AddLogEntry(e.getMessage());
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
PlayerData getPlayerDataFromStorage(UUID playerID)
|
|
{
|
|
PlayerData playerData = new PlayerData();
|
|
playerData.playerID = playerID;
|
|
|
|
try (PreparedStatement selectStmnt = this.databaseConnection.prepareStatement(this.getGetPlayerDataSQL()))
|
|
{
|
|
selectStmnt.setString(1, playerID.toString());
|
|
ResultSet results = selectStmnt.executeQuery();
|
|
|
|
//if data for this player exists, use it
|
|
if (results.next())
|
|
{
|
|
playerData.setAccruedClaimBlocks(results.getInt("accruedblocks"));
|
|
playerData.setBonusClaimBlocks(results.getInt("bonusblocks"));
|
|
}
|
|
}
|
|
catch (SQLException e)
|
|
{
|
|
StringWriter errors = new StringWriter();
|
|
e.printStackTrace(new PrintWriter(errors));
|
|
GriefPrevention.AddLogEntry(playerID + " " + errors.toString(), CustomLogEntryTypes.Exception);
|
|
}
|
|
|
|
return playerData;
|
|
}
|
|
|
|
//saves changes to player data. MUST be called after you're done making changes, otherwise a reload will lose them
|
|
@Override
|
|
public void overrideSavePlayerData(UUID playerID, PlayerData playerData)
|
|
{
|
|
//never save data for the "administrative" account. an empty string for player name indicates administrative account
|
|
if (playerID == null) return;
|
|
|
|
this.savePlayerData(playerID.toString(), playerData);
|
|
}
|
|
|
|
private void savePlayerData(String playerID, PlayerData playerData)
|
|
{
|
|
try (PreparedStatement deleteStmnt = this.databaseConnection.prepareStatement(this.getDeletePlayerDataSQL());
|
|
PreparedStatement insertStmnt = this.databaseConnection.prepareStatement(this.getInsertPlayerDataSQL()))
|
|
{
|
|
OfflinePlayer player = Bukkit.getOfflinePlayer(UUID.fromString(playerID));
|
|
|
|
SimpleDateFormat sqlFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
|
String dateString = sqlFormat.format(new Date(player.getLastPlayed()));
|
|
deleteStmnt.setString(1, playerID);
|
|
deleteStmnt.executeUpdate();
|
|
|
|
insertStmnt.setString(1, playerID);
|
|
insertStmnt.setString(2, dateString);
|
|
insertStmnt.setInt(3, playerData.getAccruedClaimBlocks());
|
|
insertStmnt.setInt(4, playerData.getBonusClaimBlocks());
|
|
insertStmnt.executeUpdate();
|
|
}
|
|
catch (SQLException e)
|
|
{
|
|
StringWriter errors = new StringWriter();
|
|
e.printStackTrace(new PrintWriter(errors));
|
|
GriefPrevention.AddLogEntry(playerID + " " + errors.toString(), CustomLogEntryTypes.Exception);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
synchronized void incrementNextClaimID()
|
|
{
|
|
this.setNextClaimID(this.nextClaimID + 1);
|
|
}
|
|
|
|
//sets the next claim ID. used by incrementNextClaimID() above, and also while migrating data from a flat file data store
|
|
synchronized void setNextClaimID(long nextID)
|
|
{
|
|
this.nextClaimID = nextID;
|
|
|
|
try (PreparedStatement deleteStmnt = this.databaseConnection.prepareStatement(this.getDeleteNextClaimIdSQL());
|
|
PreparedStatement insertStmnt = this.databaseConnection.prepareStatement(this.getInsertNextClaimIdSQL()))
|
|
{
|
|
deleteStmnt.execute();
|
|
insertStmnt.setLong(1, nextID);
|
|
insertStmnt.executeUpdate();
|
|
}
|
|
catch (SQLException e)
|
|
{
|
|
GriefPrevention.AddLogEntry("Unable to set next claim ID to " + nextID + ". Details:");
|
|
GriefPrevention.AddLogEntry(e.getMessage());
|
|
}
|
|
}
|
|
|
|
//updates the database with a group's bonus blocks
|
|
@Override
|
|
synchronized void saveGroupBonusBlocks(String groupName, int currentValue)
|
|
{
|
|
//group bonus blocks are stored in the player data table, with player name = $groupName
|
|
try (PreparedStatement deleteStmnt = this.databaseConnection.prepareStatement(this.getDeleteGroupBonusSQL());
|
|
PreparedStatement insertStmnt = this.databaseConnection.prepareStatement(this.getInsertPlayerDataSQL()))
|
|
{
|
|
SimpleDateFormat sqlFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
|
String dateString = sqlFormat.format(new Date());
|
|
deleteStmnt.setString(1, '$' + groupName);
|
|
deleteStmnt.executeUpdate();
|
|
|
|
insertStmnt.setString(1, '$' + groupName);
|
|
insertStmnt.setString(2, dateString);
|
|
insertStmnt.setInt(3, 0);
|
|
insertStmnt.setInt(4, currentValue);
|
|
insertStmnt.executeUpdate();
|
|
}
|
|
catch (SQLException e)
|
|
{
|
|
GriefPrevention.AddLogEntry("Unable to save data for group " + groupName + ". Details:");
|
|
GriefPrevention.AddLogEntry(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
synchronized void close()
|
|
{
|
|
if (this.databaseConnection != null)
|
|
{
|
|
try
|
|
{
|
|
if (!this.databaseConnection.isClosed())
|
|
{
|
|
this.databaseConnection.close();
|
|
}
|
|
}
|
|
catch (SQLException e) {}
|
|
;
|
|
}
|
|
|
|
this.databaseConnection = null;
|
|
}
|
|
|
|
private synchronized void refreshDataConnection() throws SQLException
|
|
{
|
|
if (this.databaseConnection == null || !this.databaseConnection.isValid(3))
|
|
{
|
|
if (this.databaseConnection != null && !this.databaseConnection.isClosed())
|
|
{
|
|
this.databaseConnection.close();
|
|
}
|
|
|
|
//set username/pass properties
|
|
Properties connectionProps = new Properties();
|
|
connectionProps.put("user", this.userName);
|
|
connectionProps.put("password", this.password);
|
|
connectionProps.put("autoReconnect", "true");
|
|
connectionProps.put("maxReconnects", String.valueOf(Integer.MAX_VALUE));
|
|
|
|
//establish connection
|
|
this.databaseConnection = DriverManager.getConnection(this.databaseUrl, connectionProps);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected int getSchemaVersionFromStorage()
|
|
{
|
|
try (PreparedStatement selectStmnt = this.databaseConnection.prepareStatement(this.getSelectSchemaVersionSQL()))
|
|
{
|
|
ResultSet results = selectStmnt.executeQuery();
|
|
|
|
//if there's nothing yet, assume 0 and add it
|
|
if (!results.next())
|
|
{
|
|
this.setSchemaVersion(0);
|
|
return 0;
|
|
}
|
|
//otherwise return the value that's in the table
|
|
else
|
|
{
|
|
return results.getInt("version");
|
|
}
|
|
}
|
|
catch (SQLException e)
|
|
{
|
|
GriefPrevention.AddLogEntry("Unable to retrieve schema version from database. Details:");
|
|
GriefPrevention.AddLogEntry(e.getMessage());
|
|
e.printStackTrace();
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void updateSchemaVersionInStorage(int versionToSet)
|
|
{
|
|
try (PreparedStatement deleteStmnt = this.databaseConnection.prepareStatement(this.getDeleteSchemaVersionSQL());
|
|
PreparedStatement insertStmnt = this.databaseConnection.prepareStatement(this.getInsertSchemaVerSQL()))
|
|
{
|
|
deleteStmnt.execute();
|
|
|
|
insertStmnt.setInt(1, versionToSet);
|
|
insertStmnt.executeUpdate();
|
|
}
|
|
catch (SQLException e)
|
|
{
|
|
GriefPrevention.AddLogEntry("Unable to set next schema version to " + versionToSet + ". Details:");
|
|
GriefPrevention.AddLogEntry(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Concats an array to a string divided with the ; sign
|
|
*
|
|
* @param input Arraylist with strings to concat
|
|
* @return String with all values from input array
|
|
*/
|
|
private String storageStringBuilder(ArrayList<String> input)
|
|
{
|
|
String output = "";
|
|
for (String string : input)
|
|
{
|
|
output += string + ";";
|
|
}
|
|
return output;
|
|
}
|
|
|
|
public String getUpdateNameSQL()
|
|
{
|
|
return updateNameSQL;
|
|
}
|
|
|
|
public String getInsertClaimSQL()
|
|
{
|
|
return insertClaimSQL;
|
|
}
|
|
|
|
public String getDeleteClaimSQL()
|
|
{
|
|
return deleteClaimSQL;
|
|
}
|
|
|
|
public String getGetPlayerDataSQL()
|
|
{
|
|
return getPlayerDataSQL;
|
|
}
|
|
|
|
public String getDeletePlayerDataSQL()
|
|
{
|
|
return deletePlayerDataSQL;
|
|
}
|
|
|
|
public String getInsertPlayerDataSQL()
|
|
{
|
|
return insertPlayerDataSQL;
|
|
}
|
|
|
|
public String getInsertNextClaimIdSQL()
|
|
{
|
|
return insertNextClaimIdSQL;
|
|
}
|
|
|
|
public String getDeleteGroupBonusSQL()
|
|
{
|
|
return deleteGroupBonusSQL;
|
|
}
|
|
|
|
public String getInsertSchemaVerSQL()
|
|
{
|
|
return insertSchemaVerSQL;
|
|
}
|
|
|
|
public String getDeleteNextClaimIdSQL()
|
|
{
|
|
return deleteNextClaimIdSQL;
|
|
}
|
|
|
|
public String getDeleteSchemaVersionSQL()
|
|
{
|
|
return deleteSchemaVersionSQL;
|
|
}
|
|
|
|
public String getSelectSchemaVersionSQL()
|
|
{
|
|
return selectSchemaVersionSQL;
|
|
}
|
|
}
|