🎉 Created mongoDb and MySQL data.

pom.xml

@@ -133,14 +133,18 @@
         <dependency>
             <groupId>com.zaxxer</groupId>
             <artifactId>HikariCP</artifactId>
-            <version>5.0.0</version>
+            <version>4.0.3</version>
         </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
             <version>1.18.20</version>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>org.mongodb</groupId>
+            <artifactId>mongo-java-driver</artifactId>
+            <version>3.12.10</version>
+        </dependency>
     </dependencies>
-
 </project>

src/main/java/pl/minecodes/mineeconomy/EconomyPlugin.java

@@ -13,10 +13,14 @@
 import pl.minecodes.mineeconomy.data.configuration.Configuration;
 import pl.minecodes.mineeconomy.data.configuration.Messages;
 import pl.minecodes.mineeconomy.data.configuration.helper.ConfigurationFactory;
+import pl.minecodes.mineeconomy.data.database.MongoDbService;
+import pl.minecodes.mineeconomy.data.database.MySQLService;
+import pl.minecodes.mineeconomy.data.database.element.model.DataService;
 import pl.minecodes.mineeconomy.hook.placeholderapi.PlaceholderAPIHook;
 import pl.minecodes.mineeconomy.hook.vault.VaultHook;
 import pl.minecodes.mineeconomy.hook.vault.VaultManager;
 import pl.minecodes.mineeconomy.profile.ProfileService;
+import pl.minecodes.mineeconomy.runnable.ProfileSaveTask;
 
 import java.text.DecimalFormat;
 import java.util.Locale;
@@ -41,6 +45,21 @@ public void onEnable() {
         this.injector.registerInjectable(configuration);
         this.injector.registerInjectable(messages);
 
+        DataService dataService;
+        switch (this.configuration.getDatabaseData().getDatabaseType()) {
+            case MYSQL:
+                dataService = this.injector.createInstance(MySQLService.class);
+                dataService.connect();
+                break;
+            case MONGODB:
+                dataService = this.injector.createInstance(MongoDbService.class);
+                dataService.connect();
+                break;
+            default:
+                throw new IllegalStateException("Unexpected value: " + this.configuration.getDatabaseData().getDatabaseType());
+        }
+        this.injector.registerInjectable(dataService);
+
         this.profileService = this.injector.createInstance(ProfileService.class);
         this.injector.registerInjectable(profileService);
 
@@ -54,6 +73,8 @@ public void onEnable() {
 
         PlaceholderAPIHook papiHook = this.injector.createInstance(PlaceholderAPIHook.class);
         papiHook.registerHook();
+
+        Bukkit.getScheduler().runTaskTimerAsynchronously(this, this.injector.createInstance(ProfileSaveTask.class), 40, 40);
     }
 
     @Override

src/main/java/pl/minecodes/mineeconomy/data/configuration/Configuration.java

@@ -3,16 +3,18 @@
 import eu.okaeri.configs.OkaeriConfig;
 import eu.okaeri.configs.annotation.Comment;
 import eu.okaeri.pluralize.Pluralize;
+import pl.minecodes.mineeconomy.data.database.element.DatabaseData;
 
 import java.util.Locale;
 
 public class Configuration extends OkaeriConfig {
 
     @Comment("Nazwy waluty w odmianach.")
-    private String currency = "Iskre|Iskry|Iskier";
+    private String currency = " Iskre| Iskry| Iskier";
     private CurrencyPositionVault currencyPositionVault = CurrencyPositionVault.BEHIND;
     @Comment("Początkowy stan konta gracza.")
     private double startBalance = 10;
+    private DatabaseData databaseData = new DatabaseData();
 
 
     public String getCurrency(double value) {
@@ -46,5 +48,18 @@ public void setCurrency(String currency) {
         this.currency = currency;
     }
 
+    public String getCurrency() {
+        return currency;
+    }
+
+    public DatabaseData getDatabaseData() {
+        return databaseData;
+    }
+
+    @Deprecated
+    public void setDatabaseData(DatabaseData databaseData) {
+        this.databaseData = databaseData;
+    }
+
     public enum CurrencyPositionVault {AHEAD, BEHIND}
 }

src/main/java/pl/minecodes/mineeconomy/data/database/MongoDbService.java

@@ -0,0 +1,62 @@
+package pl.minecodes.mineeconomy.data.database;
+
+import com.mongodb.MongoClient;
+import com.mongodb.MongoCredential;
+import com.mongodb.ServerAddress;
+import com.mongodb.client.FindIterable;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.model.Filters;
+import com.mongodb.client.model.ReplaceOptions;
+import eu.okaeri.injector.annotation.Inject;
+import org.bson.Document;
+import pl.minecodes.mineeconomy.data.configuration.Configuration;
+import pl.minecodes.mineeconomy.data.database.element.DatabaseData;
+import pl.minecodes.mineeconomy.data.database.element.model.DataService;
+import pl.minecodes.mineeconomy.profile.Profile;
+
+import java.util.Collections;
+import java.util.UUID;
+import java.util.logging.Logger;
+
+public class MongoDbService implements DataService {
+
+    @Inject
+    private Logger logger;
+    @Inject
+    private Configuration configuration;
+
+    private MongoCollection<Document> mongoCollection;
+
+    @Override
+    public Profile loadData(UUID uniqueId) {
+        FindIterable<Document> findDocument = mongoCollection.find(Filters.eq("uniqueId", uniqueId.toString()));
+        Document document = findDocument.first();
+        if (document == null) return null;
+
+        return new Profile(UUID.fromString(document.getString("uniqueId")), document.getDouble("balance"));
+    }
+
+    @Override
+    public void saveData(Profile profile) {
+        Document document = new Document();
+        document.put("uniqueId", profile.getUniqueId().toString());
+        document.put("balance", profile.getBalance());
+        mongoCollection.replaceOne(Filters.eq("uniqueId", profile.getUniqueId().toString()), document, new ReplaceOptions().upsert(true));
+    }
+
+    @Override
+    public void deleteData(Profile profile) {
+        mongoCollection.deleteOne(Filters.eq("uniqueId", profile.getUniqueId().toString()));
+    }
+
+    @Override
+    public void connect() {
+        DatabaseData databaseData = this.configuration.getDatabaseData();
+        MongoCredential mongoCredential = MongoCredential.createCredential(databaseData.getUsername(), databaseData.getDatabase(), databaseData.getPassword().toCharArray());
+        MongoClient mongoClient = new MongoClient(new ServerAddress(databaseData.getHost(), databaseData.getPort()), Collections.singletonList(mongoCredential));
+        MongoDatabase mongoDatabase = mongoClient.getDatabase(databaseData.getDatabase());
+        mongoCollection = mongoDatabase.getCollection("economyUsers");
+        this.logger.info("Successfully connected to MongoDb database.");
+    }
+}

src/main/java/pl/minecodes/mineeconomy/data/database/MySQLService.java

@@ -0,0 +1,101 @@
+package pl.minecodes.mineeconomy.data.database;
+
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import eu.okaeri.injector.annotation.Inject;
+import pl.minecodes.mineeconomy.data.configuration.Configuration;
+import pl.minecodes.mineeconomy.data.database.element.model.DataService;
+import pl.minecodes.mineeconomy.profile.Profile;
+
+import java.sql.*;
+import java.util.UUID;
+import java.util.logging.Logger;
+
+public class MySQLService implements DataService {
+
+    @Inject
+    private Logger logger;
+    @Inject
+    private Configuration configuration;
+
+    private HikariDataSource dataSource;
+    private Connection connection;
+
+    @Override
+    public Profile loadData(UUID uniqueId) {
+        try (Statement statement = this.getConnection().createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE)) {
+            ResultSet resultSet = statement.executeQuery("SELECT * FROM `economyUsers` WHERE `uniqueId` = '" + uniqueId + "';");
+            if (resultSet.first()) {
+                return new Profile(uniqueId, resultSet.getDouble("balance"));
+            }
+        } catch (SQLException exception) {
+            exception.printStackTrace();
+        }
+        return null;
+    }
+
+    @Override
+    public void saveData(Profile profile) {
+        try (PreparedStatement preparedStatement = this.getConnection()
+                .prepareStatement("INSERT INTO `economyUsers` (`uniqueId`, `balance`) VALUES (?, ?) ON DUPLICATE KEY UPDATE `uniqueId` = VALUES(uniqueId), `balance` = VALUES(balance);")) {
+            preparedStatement.setString(1, profile.getUniqueId().toString());
+            preparedStatement.setDouble(2, profile.getBalance());
+            preparedStatement.executeUpdate();
+            this.logger.info("Successfully updated profile by uniqueId " + profile.getUniqueId() + " to MySQL data.");
+        } catch (SQLException exception) {
+            this.logger.severe("There was an unexpected incident, while trying to save profile with id " + profile.getUniqueId());
+            exception.printStackTrace();
+        }
+    }
+
+    @Override
+    public void deleteData(Profile profile) {
+        try (PreparedStatement preparedStatement = this.getConnection().prepareStatement("DELETE FROM `economyUsers` WHERE `uniqueId` = ?;")) {
+            preparedStatement.setString(1, profile.getUniqueId().toString());
+            preparedStatement.executeUpdate();
+        } catch (SQLException exception) {
+            this.logger.severe("There was an unexpected incident, while trying to remove plot with id " + profile.getUniqueId());
+        }
+    }
+
+    @Override
+    public void connect() {
+        dataSource = new HikariDataSource(this.getHikariConfig());
+        this.logger.info("Successfully connected to MySQL database!");
+        try (Statement statement = dataSource.getConnection().createStatement()) {
+            statement.executeUpdate("CREATE TABLE IF NOT EXISTS `economyUsers` (`uniqueId` VARCHAR(64) PRIMARY KEY, `balance` DOUBLE);");
+        } catch (SQLException exception) {
+            exception.printStackTrace();
+            this.logger.severe("There was an unexpected incident, while trying to create plots table");
+        }
+    }
+
+    private Connection getConnection() throws SQLException {
+        if (connection == null || connection.isClosed()) {
+            connection = dataSource.getConnection();
+        }
+        return connection;
+    }
+
+    private HikariConfig getHikariConfig() {
+        HikariConfig hikariConfig = new HikariConfig();
+        hikariConfig.setJdbcUrl(String.format("jdbc:mysql://%s:%d/%s",
+                configuration.getDatabaseData().getHost(),
+                configuration.getDatabaseData().getPort(),
+                configuration.getDatabaseData().getDatabase()));
+        hikariConfig.setUsername(configuration.getDatabaseData().getUsername());
+        hikariConfig.setPassword(configuration.getDatabaseData().getPassword());
+
+        hikariConfig.addDataSourceProperty("cachePrepStmts", "true");
+        hikariConfig.addDataSourceProperty("prepStmtCacheSize", "250");
+        hikariConfig.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
+        hikariConfig.addDataSourceProperty("useServerPrepStmts", "true");
+        hikariConfig.addDataSourceProperty("useLocalSessionState", "true");
+        hikariConfig.addDataSourceProperty("rewriteBatchedStatements", "true");
+        hikariConfig.addDataSourceProperty("cacheResultSetMetadata", "true");
+        hikariConfig.addDataSourceProperty("cacheServerConfiguration", "true");
+        hikariConfig.addDataSourceProperty("elideSetAutoCommits", "true");
+        hikariConfig.addDataSourceProperty("maintainTimeStats", "false");
+        return hikariConfig;
+    }
+}

src/main/java/pl/minecodes/mineeconomy/data/database/element/DatabaseData.java

@@ -0,0 +1,30 @@
+package pl.minecodes.mineeconomy.data.database.element;
+
+import eu.okaeri.configs.OkaeriConfig;
+import eu.okaeri.configs.annotation.Comment;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode(callSuper = false)
+@Data
+public class DatabaseData extends OkaeriConfig {
+
+    @Comment("Typ bazy danych: MYSQL, MONGODB")
+    private DatabaseType databaseType = DatabaseType.MYSQL;
+
+    @Comment("Adres bazy danych")
+    private String host = "localhost";
+
+    @Comment("Nazwa bazy")
+    private String database = "plots";
+
+    @Comment("Port bazy")
+    private int port = 2000;
+
+    @Comment("Użytkownik")
+    private String username = "plots";
+
+    @Comment("Hasło dostępu")
+    private String password = "password";
+
+}

src/main/java/pl/minecodes/mineeconomy/data/database/element/DatabaseType.java

@@ -0,0 +1,8 @@
+package pl.minecodes.mineeconomy.data.database.element;
+
+public enum DatabaseType {
+
+    MYSQL,
+    MONGODB
+
+}

src/main/java/pl/minecodes/mineeconomy/data/database/element/model/DataService.java

@@ -0,0 +1,17 @@
+package pl.minecodes.mineeconomy.data.database.element.model;
+
+
+import pl.minecodes.mineeconomy.profile.Profile;
+
+import java.util.UUID;
+
+public interface DataService {
+
+    Profile loadData(UUID uniqueId);
+
+    void saveData(Profile profile);
+
+    void deleteData(Profile profile);
+
+    void connect();
+}

src/main/java/pl/minecodes/mineeconomy/data/database/element/object/DatabaseUpdate.java

@@ -0,0 +1,13 @@
+package pl.minecodes.mineeconomy.data.database.element.object;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class DatabaseUpdate {
+
+    private long lastUpdate;
+    private boolean neededUpdate;
+
+}

src/main/java/pl/minecodes/mineeconomy/profile/Profile.java

@@ -10,9 +10,17 @@ public class Profile {
     private final UUID uniqueId;
     private double balance;
 
+    private boolean needUpdate;
+
     public Profile(UUID uniqueId, Configuration configuration) {
         this.uniqueId = uniqueId;
         this.balance = configuration.getStartBalance();
+        this.needUpdate = true;
+    }
+
+    public Profile(UUID uniqueId, double balance) {
+        this.uniqueId = uniqueId;
+        this.balance = balance;
     }
 
     public UUID getUniqueId() {
@@ -31,6 +39,7 @@ public void deposit(double money, BalanceOperationCallback callback) {
 
         callback.done();
         this.balance += money;
+        this.needUpdate = true;
     }
 
     public void withdraw(double money, BalanceOperationCallback callback) {
@@ -49,6 +58,7 @@ public void withdraw(double money, BalanceOperationCallback callback) {
 
         callback.done();
         this.balance -= money;
+        this.needUpdate = true;
     }
 
     public void setupBalance(double balance, BalanceOperationCallback callback) {
@@ -59,10 +69,18 @@ public void setupBalance(double balance, BalanceOperationCallback callback) {
 
         callback.done();
         this.balance = balance;
+        this.needUpdate = true;
     }
 
     public boolean has(double value) {
         return this.balance >= value;
     }
 
+    public boolean needUpdate() {
+        return needUpdate;
+    }
+
+    public void needUpdate(boolean b) {
+        this.needUpdate = b;
+    }
 }