StandardEconomyService,java

package me.ekranos.misc.economy;

import com.google.common.base.Optional;
import me.ekranos.misc.Misc;
import org.spongepowered.api.entity.player.Player;
import sun.reflect.generics.reflectiveObjects.NotImplementedException;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;

public class StandardEconomyService implements EconomyService {

    private String majorCurrencyName;
    private String majorCurrencySign;
    private String minorCurrencyName;
    private String minorCurrencySign;
    private String shortFormat;
    private String longFormat;

    public StandardEconomyService() {
        majorCurrencyName = "Euro";
        majorCurrencySign = "€";
        minorCurrencyName = "Cent";
        minorCurrencySign = "ct";
        shortFormat = "{majorValue},{minorValue} {majorName}";
        longFormat = "{majorValue} {majorName} {minorValue} {minorName}";
        getDeposit("server", true);

        recalculateAllDeposits();
    }

    private void recalculateAllDeposits() {
        Optional<Set<Deposit>> deposits = getDeposits();
        for (Deposit deposit : deposits.get()) {
            ((StandardDeposit) deposit).recalculate();
        }
    }

    @Override
    public Transaction execute(Transaction transaction) {
        return null;
    }

    @Override
    public Optional<Transaction> execute(Player source, Player target, double amount, String description) {
        return execute(source.getUniqueId(), target.getUniqueId(), amount, description);
    }

    @Override
    public Optional<Transaction> execute(UUID source, UUID target, double amount, String description) {
        return execute("player:" + source.toString(), "player:" + target.toString(), amount, description);
    }

    @Override
    public Optional<Transaction> execute(String source, String target, double amount, String description) {
        if (test(source, target, amount)) {
            StandardDeposit sourceDeposit = (StandardDeposit) getDeposit(source).get();
            StandardDeposit targetDeposit = (StandardDeposit) getDeposit(target).get();
            StandardTransaction transaction = new StandardTransaction(sourceDeposit, targetDeposit, amount, description);

            Optional<Transaction> result = Optional.of(transaction.save());
            sourceDeposit.recalculate();
            targetDeposit.recalculate();

            return result;
        }

        return Optional.absent();
    }

    @Override
    public Optional<Transaction> execute(Player target, double amount, String description) {
        return execute(target.getUniqueId(), amount, description);
    }

    @Override
    public Optional<Transaction> execute(UUID target, double amount, String description) {
        return execute("player:" + target.toString(), amount, description);
    }

    @Override
    public Optional<Transaction> execute(String target, double amount, String description) {
        if (test(target, amount)) {
            StandardDeposit targetDeposit = (StandardDeposit) getDeposit(target).get();
            StandardTransaction transaction = new StandardTransaction(getDeposit("server").get(), targetDeposit, amount, description);

            Optional<Transaction> result = Optional.of(transaction.save());

            targetDeposit.recalculate();

            return result;
        }

        return Optional.absent();
    }

    @Override
    public boolean test(Player source, Player target, double amount) {
        Deposit sourceDeposit = getDeposit(source).get();
        Deposit targetDeposit = getDeposit(target).get();

        return sourceDeposit.getAmount() - amount >= 0.0d && targetDeposit.getAmount() + amount >= 0.0d;
    }

    @Override
    public boolean test(UUID source, UUID target, double amount) {
        return false;
    }

    @Override
    public boolean test(String source, String target, double amount) {
        return false;
    }

    @Override
    public boolean test(Player target, double amount) {
        return test(target.getUniqueId(), amount);
    }

    @Override
    public boolean test(UUID target, double amount) {
        return test("player:" + target.toString(), amount);
    }

    @Override
    public boolean test(String target, double amount) {
        return getDeposit(target).get().getAmount() + amount >= 0.0d;
    }

    @Override
    public Optional<Transaction> rollback(Transaction transaction) {
        throw new NotImplementedException();
    }

    @Override
    public Optional<Deposit> getDeposit(Player player) {
        return getDeposit(player.getUniqueId());
    }

    @Override
    public Optional<Deposit> getDeposit(UUID uuid) {
        return getDeposit("player:" + uuid.toString(), true);
    }

    @Override
    public Optional<Deposit> getDeposit(String name) {
        return getDeposit(name, false);
    }

    @Override
    public Optional<Deposit> getDeposit(String name, boolean create) {
        try (Connection connection = getConnection()) {
            PreparedStatement statement = connection.prepareStatement("SELECT id FROM deposits WHERE name = ?");
            statement.setString(1, name);
            ResultSet result = statement.executeQuery();

            if (result.next()) {
                return Optional.of(new StandardDeposit(result.getInt(1)));
            } else {
                if (create) {
                    return Optional.of(new StandardDeposit(name).save());
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return Optional.absent();
    }

    @Override
    public Optional<Set<Deposit>> getDeposits() {
        Set<Deposit> deposits = new HashSet<>();

        try (Connection connection = getConnection()) {
            ResultSet result = connection.prepareStatement("SELECT id FROM deposits").executeQuery();

            while (result.next()) {
                deposits.add(new StandardDeposit(result.getInt(1)));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return Optional.of(deposits);
    }

    @Override
    public EconomyService setMajorCurrency(String name, String sign) {
        majorCurrencyName = name;
        majorCurrencySign = sign;
        return this;
    }

    @Override
    public EconomyService setMinorCurrency(String name, String sign) {
        minorCurrencyName = name;
        minorCurrencySign = sign;
        return this;
    }

    @Override
    public EconomyService setShortFormat(String format) {
        shortFormat = format;
        return this;
    }

    @Override
    public EconomyService setFullFormat(String format) {
        longFormat = format;
        return this;
    }

    @Override
    public double sanitize(double amount) {
        return Math.floor(amount * 100) / 100;
    }

    @Override
    public String format(double amount) {
        return format(amount, Format.SHORT);
    }

    @Override
    public String format(double amount, Format format) {
        return format == Format.SHORT ? format(amount, shortFormat) : format(amount, longFormat);
    }

    private String format(double amount, String format) {
        double value = Math.floor(amount * 100) / 100;
        int majorValue = new Double(amount).intValue();
        int minorValue = new Double(amount * 100).intValue() - (majorValue * 100);

        return format
                .replace("{value}", Double.toString(value).replace('.', ','))
                .replace("{majorValue}", Integer.toString(majorValue))
                .replace("{minorValue}", Integer.toString(minorValue))
                .replace("{majorName}", majorCurrencyName)
                .replace("{majorSign}", majorCurrencySign)
                .replace("{minorName}", minorCurrencyName)
                .replace("{minorSign}", minorCurrencySign);
    }

    public static Connection getConnection() throws SQLException {
        return Misc.get().getConnection();
    }
}