From 627cad0f2c1d8434f224ff70fa9400b9434effe1 Mon Sep 17 00:00:00 2001 From: mose Date: Wed, 11 Oct 2023 13:23:07 +0100 Subject: [PATCH] New accounting --- .../java/org/core/eco/CurrencyManager.java | 6 +- .../java/org/core/eco/account/Account.java | 48 +++++++++++ .../org/core/eco/account/AccountSnapshot.java | 57 +++++++++++++ .../eco => eco/account}/NamedAccount.java | 2 +- .../eco => eco/account}/PlayerAccount.java | 3 +- .../eco/transaction/AbstractTransaction.java | 27 ++++++ .../eco/transaction/SecureTransaction.java | 26 ++++++ .../org/core/eco/transaction/Transaction.java | 16 ++++ .../core/eco/transaction/TransactionType.java | 8 ++ .../pending/PendingSingleTransaction.java | 21 +++++ .../pending/PendingSingleTransactionImpl.java | 62 ++++++++++++++ .../pending/PendingTransaction.java | 37 ++++++++ .../pending/PendingTransactionsImpl.java | 84 +++++++++++++++++++ .../transaction/result/TransactionResult.java | 21 +++++ .../result/TransactionsResult.java | 13 +++ .../result/impl/TransactionResultImpl.java | 57 +++++++++++++ .../result/impl/TransactionsResultImpl.java | 20 +++++ .../core/entity/living/human/player/User.java | 6 +- .../java/org/core/source/eco/Account.java | 9 -- .../java/org/core/source/eco/EcoSource.java | 73 ---------------- 20 files changed, 502 insertions(+), 94 deletions(-) create mode 100644 src/main/java/org/core/eco/account/Account.java create mode 100644 src/main/java/org/core/eco/account/AccountSnapshot.java rename src/main/java/org/core/{source/eco => eco/account}/NamedAccount.java (63%) rename src/main/java/org/core/{source/eco => eco/account}/PlayerAccount.java (71%) create mode 100644 src/main/java/org/core/eco/transaction/AbstractTransaction.java create mode 100644 src/main/java/org/core/eco/transaction/SecureTransaction.java create mode 100644 src/main/java/org/core/eco/transaction/Transaction.java create mode 100644 src/main/java/org/core/eco/transaction/TransactionType.java create mode 100644 src/main/java/org/core/eco/transaction/pending/PendingSingleTransaction.java create mode 100644 src/main/java/org/core/eco/transaction/pending/PendingSingleTransactionImpl.java create mode 100644 src/main/java/org/core/eco/transaction/pending/PendingTransaction.java create mode 100644 src/main/java/org/core/eco/transaction/pending/PendingTransactionsImpl.java create mode 100644 src/main/java/org/core/eco/transaction/result/TransactionResult.java create mode 100644 src/main/java/org/core/eco/transaction/result/TransactionsResult.java create mode 100644 src/main/java/org/core/eco/transaction/result/impl/TransactionResultImpl.java create mode 100644 src/main/java/org/core/eco/transaction/result/impl/TransactionsResultImpl.java delete mode 100644 src/main/java/org/core/source/eco/Account.java delete mode 100644 src/main/java/org/core/source/eco/EcoSource.java diff --git a/src/main/java/org/core/eco/CurrencyManager.java b/src/main/java/org/core/eco/CurrencyManager.java index 74dacbed..ec9af15d 100644 --- a/src/main/java/org/core/eco/CurrencyManager.java +++ b/src/main/java/org/core/eco/CurrencyManager.java @@ -1,10 +1,8 @@ package org.core.eco; -import org.core.TranslateCore; import org.core.entity.living.human.player.User; -import org.core.source.eco.Account; -import org.core.source.eco.NamedAccount; -import org.core.source.eco.PlayerAccount; +import org.core.eco.account.NamedAccount; +import org.core.eco.account.PlayerAccount; import org.jetbrains.annotations.NotNull; import java.util.Collection; diff --git a/src/main/java/org/core/eco/account/Account.java b/src/main/java/org/core/eco/account/Account.java new file mode 100644 index 00000000..a8e2e837 --- /dev/null +++ b/src/main/java/org/core/eco/account/Account.java @@ -0,0 +1,48 @@ +package org.core.eco.account; + +import org.core.TranslateCore; +import org.core.eco.Currency; +import org.core.eco.transaction.*; +import org.core.eco.transaction.pending.PendingTransaction; +import org.core.source.Source; +import org.jetbrains.annotations.NotNull; + +import java.math.BigDecimal; +import java.util.List; +import java.util.function.BiFunction; + +public interface Account extends Source { + + @NotNull String getName(); + + @NotNull PendingTransaction transact(@NotNull Transaction transaction); + + default @NotNull PendingTransaction transact(@NotNull Account other, + BiFunction> transactions) { + return new SecureTransaction(this, other, transactions).run(); + } + + @NotNull BigDecimal getBalance(@NotNull Currency currency); + + default @NotNull BigDecimal getBalance() { + return this.getBalance(TranslateCore.getCurrencyManager().getDefaultCurrency()); + } + + default PendingTransaction deposit(@NotNull Currency currency, @NotNull Number amount) { + return this.transact(new DepositTransaction(this, currency, + amount instanceof BigDecimal ? (BigDecimal) amount : BigDecimal.valueOf( + amount.doubleValue()))); + } + + default PendingTransaction withdraw(@NotNull Currency currency, @NotNull Number amount) { + return this.transact(new WithdrawTransaction(this, currency, + amount instanceof BigDecimal ? (BigDecimal) amount : BigDecimal.valueOf( + amount.doubleValue()))); + } + + default PendingTransaction setBalance(@NotNull Currency currency, @NotNull Number amount) { + return this.transact(new SetTransaction(this, currency, + amount instanceof BigDecimal ? (BigDecimal) amount : BigDecimal.valueOf( + amount.doubleValue()))); + } +} diff --git a/src/main/java/org/core/eco/account/AccountSnapshot.java b/src/main/java/org/core/eco/account/AccountSnapshot.java new file mode 100644 index 00000000..0f3c2e8f --- /dev/null +++ b/src/main/java/org/core/eco/account/AccountSnapshot.java @@ -0,0 +1,57 @@ +package org.core.eco.account; + +import org.core.eco.Currency; +import org.core.eco.transaction.Transaction; +import org.core.eco.transaction.pending.PendingSingleTransactionImpl; +import org.core.eco.transaction.pending.PendingTransaction; +import org.jetbrains.annotations.NotNull; + +import java.math.BigDecimal; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.CompletableFuture; + +public class AccountSnapshot implements Account { + + private final Account account; + private Map cachedAmount = new HashMap<>(); + + public AccountSnapshot(Account account) { + this.account = account; + } + + @Override + public @NotNull String getName() { + return this.account.getName(); + } + + @Override + public @NotNull PendingTransaction transact(@NotNull Transaction transaction) { + switch (transaction.getType()) { + case DEPOSIT -> { + BigDecimal current = cachedAmount.get(transaction.getCurrency()); + if(current == null){ + current = account.getBalance(transaction.getCurrency()); + } + cachedAmount.put(transaction.getCurrency(), current.add(transaction.getAmount())); + return new PendingSingleTransactionImpl(this, transaction, CompletableFuture.completedFuture()); + } + case WITHDRAW -> { + } + case SET -> { + } + } + return null; + } + + @Override + public @NotNull BigDecimal getBalance(@NotNull Currency currency) { + BigDecimal amount = this.cachedAmount.get(currency); + if (amount != null) { + return amount; + } + amount = this.account.getBalance(currency); + this.cachedAmount.put(currency, amount); + return amount; + } +} diff --git a/src/main/java/org/core/source/eco/NamedAccount.java b/src/main/java/org/core/eco/account/NamedAccount.java similarity index 63% rename from src/main/java/org/core/source/eco/NamedAccount.java rename to src/main/java/org/core/eco/account/NamedAccount.java index 6410149f..b8673294 100644 --- a/src/main/java/org/core/source/eco/NamedAccount.java +++ b/src/main/java/org/core/eco/account/NamedAccount.java @@ -1,4 +1,4 @@ -package org.core.source.eco; +package org.core.eco.account; public interface NamedAccount extends Account { diff --git a/src/main/java/org/core/source/eco/PlayerAccount.java b/src/main/java/org/core/eco/account/PlayerAccount.java similarity index 71% rename from src/main/java/org/core/source/eco/PlayerAccount.java rename to src/main/java/org/core/eco/account/PlayerAccount.java index eb02bf6f..d9d1f7da 100644 --- a/src/main/java/org/core/source/eco/PlayerAccount.java +++ b/src/main/java/org/core/eco/account/PlayerAccount.java @@ -1,6 +1,5 @@ -package org.core.source.eco; +package org.core.eco.account; -import org.core.entity.living.human.player.User; import org.jetbrains.annotations.NotNull; import java.util.UUID; diff --git a/src/main/java/org/core/eco/transaction/AbstractTransaction.java b/src/main/java/org/core/eco/transaction/AbstractTransaction.java new file mode 100644 index 00000000..0d1e3c64 --- /dev/null +++ b/src/main/java/org/core/eco/transaction/AbstractTransaction.java @@ -0,0 +1,27 @@ +package org.core.eco.transaction; + +import org.core.eco.Currency; +import org.jetbrains.annotations.NotNull; + +import java.math.BigDecimal; + +class AbstractTransaction implements Transaction { + + private final Currency currency; + private final BigDecimal amount; + + AbstractTransaction(Currency currency, BigDecimal amount) { + this.amount = amount; + this.currency = currency; + } + + @Override + public @NotNull Currency getCurrency() { + return this.currency; + } + + @Override + public @NotNull BigDecimal getAmount() { + return this.amount; + } +} diff --git a/src/main/java/org/core/eco/transaction/SecureTransaction.java b/src/main/java/org/core/eco/transaction/SecureTransaction.java new file mode 100644 index 00000000..3a810133 --- /dev/null +++ b/src/main/java/org/core/eco/transaction/SecureTransaction.java @@ -0,0 +1,26 @@ +package org.core.eco.transaction; + +import org.core.eco.account.Account; +import org.core.eco.transaction.pending.PendingTransaction; + +import java.util.Collection; +import java.util.function.BiFunction; + +public class SecureTransaction { + + private Account target; + private Account other; + private BiFunction> transactions; + + public SecureTransaction(Account target, + Account other, + BiFunction> transactions) { + this.target = target; + this.other = other; + this.transactions = transactions; + } + + public PendingTransaction run() { + + } +} diff --git a/src/main/java/org/core/eco/transaction/Transaction.java b/src/main/java/org/core/eco/transaction/Transaction.java new file mode 100644 index 00000000..d104fddd --- /dev/null +++ b/src/main/java/org/core/eco/transaction/Transaction.java @@ -0,0 +1,16 @@ +package org.core.eco.transaction; + +import org.core.eco.Currency; +import org.jetbrains.annotations.NotNull; + +import java.math.BigDecimal; + +public interface Transaction { + + @NotNull Currency getCurrency(); + + @NotNull BigDecimal getAmount(); + + @NotNull TransactionType getType(); + +} diff --git a/src/main/java/org/core/eco/transaction/TransactionType.java b/src/main/java/org/core/eco/transaction/TransactionType.java new file mode 100644 index 00000000..76fe3056 --- /dev/null +++ b/src/main/java/org/core/eco/transaction/TransactionType.java @@ -0,0 +1,8 @@ +package org.core.eco.transaction; + +public enum TransactionType { + + DEPOSIT, + WITHDRAW, + SET +} diff --git a/src/main/java/org/core/eco/transaction/pending/PendingSingleTransaction.java b/src/main/java/org/core/eco/transaction/pending/PendingSingleTransaction.java new file mode 100644 index 00000000..8e6e5272 --- /dev/null +++ b/src/main/java/org/core/eco/transaction/pending/PendingSingleTransaction.java @@ -0,0 +1,21 @@ +package org.core.eco.transaction.pending; + +import org.core.eco.transaction.Transaction; +import org.jetbrains.annotations.NotNull; + +import java.util.Collections; +import java.util.List; + +public interface PendingSingleTransaction extends PendingTransaction { + + @NotNull Transaction getTransaction(); + + @Override + @Deprecated + default @NotNull List getRemainingTransactions() { + if (this.isComplete()) { + return Collections.emptyList(); + } + return Collections.singletonList(this.getTransaction()); + } +} diff --git a/src/main/java/org/core/eco/transaction/pending/PendingSingleTransactionImpl.java b/src/main/java/org/core/eco/transaction/pending/PendingSingleTransactionImpl.java new file mode 100644 index 00000000..f2f74fa8 --- /dev/null +++ b/src/main/java/org/core/eco/transaction/pending/PendingSingleTransactionImpl.java @@ -0,0 +1,62 @@ +package org.core.eco.transaction.pending; + +import org.core.eco.account.Account; +import org.core.eco.transaction.Transaction; +import org.core.eco.transaction.result.TransactionResult; +import org.core.eco.transaction.result.TransactionsResult; +import org.core.eco.transaction.result.impl.TransactionsResultImpl; +import org.jetbrains.annotations.NotNull; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.CompletableFuture; + +public class PendingSingleTransactionImpl implements PendingSingleTransaction { + + private final Account account; + private final Transaction transaction; + private final List result = new ArrayList<>(); + private final CompletableFuture future; + + public PendingSingleTransactionImpl(Account account, + Transaction transaction, + CompletableFuture future) { + this.future = future.thenApply(result -> { + this.result.add(result); + return result; + }); + this.transaction = transaction; + this.account = account; + } + + + @Override + public @NotNull Transaction getTransaction() { + return this.transaction; + } + + @Override + public @NotNull Account getTarget() { + return this.account; + } + + @Override + public @NotNull TransactionsResult getCurrentResult() { + return new TransactionsResultImpl(this.result); + } + + @Override + public @NotNull CompletableFuture awaitCurrentTransaction() { + return this.future; + } + + @Override + public @NotNull CompletableFuture awaitComplete() { + return this.awaitCurrentTransaction().thenApply(t -> this.getCurrentResult()); + } + + @Override + public boolean isComplete() { + return !this.result.isEmpty(); + } +} diff --git a/src/main/java/org/core/eco/transaction/pending/PendingTransaction.java b/src/main/java/org/core/eco/transaction/pending/PendingTransaction.java new file mode 100644 index 00000000..259d37cb --- /dev/null +++ b/src/main/java/org/core/eco/transaction/pending/PendingTransaction.java @@ -0,0 +1,37 @@ +package org.core.eco.transaction.pending; + +import org.core.eco.account.Account; +import org.core.eco.transaction.Transaction; +import org.core.eco.transaction.result.TransactionResult; +import org.core.eco.transaction.result.TransactionsResult; +import org.jetbrains.annotations.NotNull; + +import java.util.List; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; + +public interface PendingTransaction { + + @NotNull List getRemainingTransactions(); + + @NotNull Account getTarget(); + + @NotNull TransactionsResult getCurrentResult(); + + @NotNull CompletableFuture awaitCurrentTransaction(); + + @NotNull CompletableFuture awaitComplete(); + + boolean isComplete(); + + default Optional getCurrentTransaction() { + List remaining = this.getRemainingTransactions(); + if (remaining.isEmpty()) { + return Optional.empty(); + } + return Optional.of(remaining.get(0)); + } + + ; + +} diff --git a/src/main/java/org/core/eco/transaction/pending/PendingTransactionsImpl.java b/src/main/java/org/core/eco/transaction/pending/PendingTransactionsImpl.java new file mode 100644 index 00000000..254eff74 --- /dev/null +++ b/src/main/java/org/core/eco/transaction/pending/PendingTransactionsImpl.java @@ -0,0 +1,84 @@ +package org.core.eco.transaction.pending; + +import org.core.eco.account.Account; +import org.core.eco.transaction.Transaction; +import org.core.eco.transaction.result.TransactionResult; +import org.core.eco.transaction.result.TransactionsResult; +import org.core.eco.transaction.result.impl.TransactionsResultImpl; +import org.jetbrains.annotations.NotNull; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.stream.Collectors; + +public class PendingTransactionsImpl implements PendingTransaction { + + private final List transactions; + + public PendingTransactionsImpl(PendingTransaction... array) { + this(Arrays.asList(array)); + } + + public PendingTransactionsImpl(Collection collection) { + this.transactions = new ArrayList<>(collection); + } + + @Override + public @NotNull List getRemainingTransactions() { + return this.transactions + .stream() + .filter(transaction -> !transaction.isComplete()) + .map(transaction -> transaction + .getCurrentTransaction() + .orElseThrow(() -> new RuntimeException("not completed transaction but no remaining?"))) + .collect(Collectors.toList()); + } + + @Override + public @NotNull Account getTarget() { + return this.transactions + .stream() + .map(PendingTransaction::getTarget) + .findAny() + .orElseThrow(() -> new RuntimeException("No transactions found")); + } + + @Override + public @NotNull TransactionsResult getCurrentResult() { + return new TransactionsResultImpl(this.transactions + .stream() + .flatMap(pending -> pending + .getCurrentResult() + .getTransactions() + .stream()) + .toList()); + } + + @Override + public @NotNull CompletableFuture awaitCurrentTransaction() { + return this.transactions + .stream() + .filter(pending -> !pending.isComplete()) + .findFirst() + .map(PendingTransaction::awaitCurrentTransaction) + .orElseGet(() -> this.transactions.get(this.transactions.size() - 1).awaitCurrentTransaction()); + } + + @Override + public @NotNull CompletableFuture awaitComplete() { + return this.transactions + .stream() + .filter(pending -> !pending.isComplete()) + .findFirst() + .map(PendingTransaction::awaitComplete) + .orElseGet(() -> this.transactions.get(this.transactions.size() - 1).awaitComplete()); + } + + @Override + public boolean isComplete() { + return this.transactions.stream().allMatch(PendingTransaction::isComplete); + } +} diff --git a/src/main/java/org/core/eco/transaction/result/TransactionResult.java b/src/main/java/org/core/eco/transaction/result/TransactionResult.java new file mode 100644 index 00000000..6454db1d --- /dev/null +++ b/src/main/java/org/core/eco/transaction/result/TransactionResult.java @@ -0,0 +1,21 @@ +package org.core.eco.transaction.result; + +import org.core.eco.transaction.Transaction; +import org.jetbrains.annotations.NotNull; + +import java.math.BigDecimal; +import java.util.Optional; + +public interface TransactionResult { + + @NotNull Transaction getTransaction(); + + boolean wasSuccessful(); + + @NotNull BigDecimal getOriginalAmount(); + + @NotNull BigDecimal getAfterAmount(); + + Optional getFailedReason(); + +} diff --git a/src/main/java/org/core/eco/transaction/result/TransactionsResult.java b/src/main/java/org/core/eco/transaction/result/TransactionsResult.java new file mode 100644 index 00000000..17aa226f --- /dev/null +++ b/src/main/java/org/core/eco/transaction/result/TransactionsResult.java @@ -0,0 +1,13 @@ +package org.core.eco.transaction.result; + +import java.util.List; + +public interface TransactionsResult { + + default boolean wasSuccessful() { + return getTransactions().stream().allMatch(TransactionResult::wasSuccessful); + } + + List getTransactions(); + +} diff --git a/src/main/java/org/core/eco/transaction/result/impl/TransactionResultImpl.java b/src/main/java/org/core/eco/transaction/result/impl/TransactionResultImpl.java new file mode 100644 index 00000000..7df3dc3a --- /dev/null +++ b/src/main/java/org/core/eco/transaction/result/impl/TransactionResultImpl.java @@ -0,0 +1,57 @@ +package org.core.eco.transaction.result.impl; + +import org.core.eco.transaction.Transaction; +import org.core.eco.transaction.result.TransactionResult; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.math.BigDecimal; +import java.util.Optional; + +public class TransactionResultImpl implements TransactionResult { + + private final Transaction transaction; + private final BigDecimal originalAmount; + private final BigDecimal afterAmount; + private @Nullable String errorMessage; + + public TransactionResultImpl(@NotNull Transaction transaction, + @NotNull BigDecimal original, + @NotNull String errorMessage) { + this.transaction = transaction; + this.originalAmount = original; + this.errorMessage = errorMessage; + this.afterAmount = original; + } + + public TransactionResultImpl(@NotNull Transaction transaction, BigDecimal original, @NotNull BigDecimal after) { + this.transaction = transaction; + this.originalAmount = original; + this.afterAmount = after; + } + + @Override + public @NotNull Transaction getTransaction() { + return this.transaction; + } + + @Override + public boolean wasSuccessful() { + return this.errorMessage == null; + } + + @Override + public @NotNull BigDecimal getOriginalAmount() { + return this.originalAmount; + } + + @Override + public @NotNull BigDecimal getAfterAmount() { + return this.afterAmount; + } + + @Override + public Optional getFailedReason() { + return Optional.ofNullable(this.errorMessage); + } +} diff --git a/src/main/java/org/core/eco/transaction/result/impl/TransactionsResultImpl.java b/src/main/java/org/core/eco/transaction/result/impl/TransactionsResultImpl.java new file mode 100644 index 00000000..ff8633fa --- /dev/null +++ b/src/main/java/org/core/eco/transaction/result/impl/TransactionsResultImpl.java @@ -0,0 +1,20 @@ +package org.core.eco.transaction.result.impl; + +import org.core.eco.transaction.result.TransactionResult; +import org.core.eco.transaction.result.TransactionsResult; + +import java.util.List; + +public class TransactionsResultImpl implements TransactionsResult { + + private final List results; + + public TransactionsResultImpl(List results) { + this.results = results; + } + + @Override + public List getTransactions() { + return this.results; + } +} diff --git a/src/main/java/org/core/entity/living/human/player/User.java b/src/main/java/org/core/entity/living/human/player/User.java index 32eee11b..a8f0d82d 100644 --- a/src/main/java/org/core/entity/living/human/player/User.java +++ b/src/main/java/org/core/entity/living/human/player/User.java @@ -1,12 +1,8 @@ package org.core.entity.living.human.player; import org.core.TranslateCore; -import org.core.eco.Currency; -import org.core.source.eco.EcoSource; -import org.core.source.eco.PlayerAccount; -import org.jetbrains.annotations.NotNull; +import org.core.eco.account.PlayerAccount; -import java.math.BigDecimal; import java.util.Optional; import java.util.UUID; import java.util.concurrent.CompletableFuture; diff --git a/src/main/java/org/core/source/eco/Account.java b/src/main/java/org/core/source/eco/Account.java deleted file mode 100644 index 6d772436..00000000 --- a/src/main/java/org/core/source/eco/Account.java +++ /dev/null @@ -1,9 +0,0 @@ -package org.core.source.eco; - -import org.jetbrains.annotations.NotNull; - -public interface Account extends EcoSource { - - @NotNull String getName(); - -} diff --git a/src/main/java/org/core/source/eco/EcoSource.java b/src/main/java/org/core/source/eco/EcoSource.java deleted file mode 100644 index ff71ba3d..00000000 --- a/src/main/java/org/core/source/eco/EcoSource.java +++ /dev/null @@ -1,73 +0,0 @@ -package org.core.source.eco; - -import net.kyori.adventure.text.serializer.plain.PlainComponentSerializer; -import org.core.TranslateCore; -import org.core.eco.Currency; -import org.core.source.Source; -import org.jetbrains.annotations.NotNull; - -import java.math.BigDecimal; - -public interface EcoSource extends Source { - - BigDecimal getBalance(@NotNull Currency currency); - - default BigDecimal getBalance() { - return this.getBalance(TranslateCore.getCurrencyManager().getDefaultCurrency()); - } - - default void setBalance(@NotNull BigDecimal decimal) { - this.setBalance(TranslateCore.getCurrencyManager().getDefaultCurrency(), decimal); - } - - default void setBalance(@NotNull Number amount) { - this.setBalance(TranslateCore.getCurrencyManager().getDefaultCurrency(), amount); - } - - void setBalance(@NotNull Currency currency, @NotNull BigDecimal decimal); - - default void setBalance(@NotNull Currency currency, Number amount) { - this.setBalance(currency, BigDecimal.valueOf(amount.doubleValue())); - - } - - default void addBalance(@NotNull BigDecimal decimal) { - this.addBalance(TranslateCore.getCurrencyManager().getDefaultCurrency(), decimal); - } - - default void addBalance(@NotNull Currency currency, @NotNull BigDecimal decimal) { - this.setBalance(currency, decimal.add(this.getBalance(currency))); - } - - default void addBalance(@NotNull Currency currency, @NotNull Number amount) { - this.addBalance(currency, BigDecimal.valueOf(amount.doubleValue())); - } - - default void addBalance(@NotNull Number amount) { - this.addBalance(TranslateCore.getCurrencyManager().getDefaultCurrency(), amount); - } - - default void removeBalance(@NotNull Currency currency, @NotNull BigDecimal decimal) { - BigDecimal bal = this.getBalance(currency); - if (bal.compareTo(decimal) < 0) { - throw new IllegalStateException( - "Costs " + PlainComponentSerializer.plain().serialize(currency.asDisplay(decimal)) - + ", you don't have enough. You have " + PlainComponentSerializer - .plain() - .serialize(currency.asDisplay(this.getBalance()))); - } - this.setBalance(bal.subtract(decimal)); - } - - default void removeBalance(@NotNull BigDecimal decimal) { - this.removeBalance(TranslateCore.getCurrencyManager().getDefaultCurrency(), decimal); - } - - default void removeBalance(@NotNull Currency currency, @NotNull Number amount) { - this.removeBalance(currency, BigDecimal.valueOf(amount.doubleValue())); - } - - default void removeBalance(@NotNull Number amount) { - this.removeBalance(BigDecimal.valueOf(amount.doubleValue())); - } -}