mirrors/bisq
1
0
Fork 0
mirror of https://github.com/bisq-network/bisq.git synced 2025-02-24 15:10:44 +01:00
Code Issues Projects Releases Packages Wiki Activity

Use PersistenceManager

Browse source
This commit is contained in:
chimp1984 2020-10-01 19:12:48 -05:00
parent f4165dc9af
commit c3c869b5ad
No known key found for this signature in database
GPG key ID: 9801B4EC591F90E3
1 changed files with 63 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

123
core/src/main/java/bisq/core/user/User.java
View file

@ -31,8 +31,8 @@ import bisq.core.support.dispute.refund.refundagent.RefundAgent;
import bisq.network.p2p.NodeAddress; import bisq.network.p2p.NodeAddress;
import bisq.common.crypto.KeyRing; import bisq.common.crypto.KeyRing;
import bisq.common.persistence.PersistenceManager;
import bisq.common.proto.persistable.PersistedDataHost; import bisq.common.proto.persistable.PersistedDataHost;
import bisq.common.storage.Storage;
import javax.inject.Inject; import javax.inject.Inject;
import javax.inject.Singleton; import javax.inject.Singleton;
@ -67,8 +67,8 @@ import static com.google.common.base.Preconditions.checkNotNull;
@AllArgsConstructor @AllArgsConstructor
@Singleton @Singleton
public class User implements PersistedDataHost { public class User implements PersistedDataHost {
final private Storage<UserPayload> storage; private final PersistenceManager<UserPayload> persistenceManager;
final private KeyRing keyRing; private final KeyRing keyRing;
private ObservableSet<PaymentAccount> paymentAccountsAsObservable; private ObservableSet<PaymentAccount> paymentAccountsAsObservable;
private ObjectProperty<PaymentAccount> currentPaymentAccountProperty; private ObjectProperty<PaymentAccount> currentPaymentAccountProperty;
@ -77,27 +77,31 @@ public class User implements PersistedDataHost {
private boolean isPaymentAccountImport = false; private boolean isPaymentAccountImport = false;
@Inject @Inject
public User(Storage<UserPayload> storage, KeyRing keyRing) { public User(PersistenceManager<UserPayload> persistenceManager, KeyRing keyRing) {
this.storage = storage; this.persistenceManager = persistenceManager;
this.keyRing = keyRing; this.keyRing = keyRing;
} }
// for unit tests // for unit tests
public User() { public User() {
storage = null; persistenceManager = null;
keyRing = null; keyRing = null;
} }
@Override @Override
public void readPersisted() { public void readPersisted() {
UserPayload persisted = storage.initAndGetPersistedWithFileName("UserPayload", 100); UserPayload persisted = checkNotNull(persistenceManager).getPersisted("UserPayload");
userPayload = persisted != null ? persisted : new UserPayload(); if (persisted != null) {
userPayload = persisted;
}
persistenceManager.initialize(userPayload, PersistenceManager.Priority.HIGH);
checkNotNull(userPayload.getPaymentAccounts(), "userPayload.getPaymentAccounts() must not be null"); checkNotNull(userPayload.getPaymentAccounts(), "userPayload.getPaymentAccounts() must not be null");
checkNotNull(userPayload.getAcceptedLanguageLocaleCodes(), "userPayload.getAcceptedLanguageLocaleCodes() must not be null"); checkNotNull(userPayload.getAcceptedLanguageLocaleCodes(), "userPayload.getAcceptedLanguageLocaleCodes() must not be null");
paymentAccountsAsObservable = FXCollections.observableSet(userPayload.getPaymentAccounts()); paymentAccountsAsObservable = FXCollections.observableSet(userPayload.getPaymentAccounts());
currentPaymentAccountProperty = new SimpleObjectProperty<>(userPayload.getCurrentPaymentAccount()); currentPaymentAccountProperty = new SimpleObjectProperty<>(userPayload.getCurrentPaymentAccount());
userPayload.setAccountId(String.valueOf(Math.abs(keyRing.getPubKeyRing().hashCode()))); userPayload.setAccountId(String.valueOf(Math.abs(checkNotNull(keyRing).getPubKeyRing().hashCode())));
// language setup // language setup
if (!userPayload.getAcceptedLanguageLocaleCodes().contains(LanguageUtil.getDefaultLanguageLocaleAsCode())) if (!userPayload.getAcceptedLanguageLocaleCodes().contains(LanguageUtil.getDefaultLanguageLocaleAsCode()))
@ -108,17 +112,19 @@ public class User implements PersistedDataHost {
paymentAccountsAsObservable.addListener((SetChangeListener<PaymentAccount>) change -> { paymentAccountsAsObservable.addListener((SetChangeListener<PaymentAccount>) change -> {
userPayload.setPaymentAccounts(new HashSet<>(paymentAccountsAsObservable)); userPayload.setPaymentAccounts(new HashSet<>(paymentAccountsAsObservable));
persist(); requestPersistence();
}); });
currentPaymentAccountProperty.addListener((ov) -> { currentPaymentAccountProperty.addListener((ov) -> {
userPayload.setCurrentPaymentAccount(currentPaymentAccountProperty.get()); userPayload.setCurrentPaymentAccount(currentPaymentAccountProperty.get());
persist(); requestPersistence();
}); });
requestPersistence();
} }
public void persist() { public void requestPersistence() {
if (storage != null) if (persistenceManager != null)
storage.queueUpForSave(userPayload); persistenceManager.requestPersistence();
} }
@ -192,6 +198,7 @@ public class User implements PersistedDataHost {
public void addPaymentAccountIfNotExists(PaymentAccount paymentAccount) { public void addPaymentAccountIfNotExists(PaymentAccount paymentAccount) {
if (!paymentAccountExists(paymentAccount)) { if (!paymentAccountExists(paymentAccount)) {
addPaymentAccount(paymentAccount); addPaymentAccount(paymentAccount);
requestPersistence();
} }
} }
@ -201,16 +208,16 @@ public class User implements PersistedDataHost {
boolean changed = paymentAccountsAsObservable.add(paymentAccount); boolean changed = paymentAccountsAsObservable.add(paymentAccount);
setCurrentPaymentAccount(paymentAccount); setCurrentPaymentAccount(paymentAccount);
if (changed) if (changed)
persist(); requestPersistence();
} }
public void addImportedPaymentAccounts(Collection<PaymentAccount> paymentAccounts) { public void addImportedPaymentAccounts(Collection<PaymentAccount> paymentAccounts) {
isPaymentAccountImport = true; isPaymentAccountImport = true;
boolean changed = paymentAccountsAsObservable.addAll(paymentAccounts); boolean changed = paymentAccountsAsObservable.addAll(paymentAccounts);
setCurrentPaymentAccount(paymentAccounts.stream().findFirst().get()); paymentAccounts.stream().findFirst().ifPresent(this::setCurrentPaymentAccount);
if (changed) if (changed)
persist(); requestPersistence();
isPaymentAccountImport = false; isPaymentAccountImport = false;
} }
@ -218,16 +225,15 @@ public class User implements PersistedDataHost {
public void removePaymentAccount(PaymentAccount paymentAccount) { public void removePaymentAccount(PaymentAccount paymentAccount) {
boolean changed = paymentAccountsAsObservable.remove(paymentAccount); boolean changed = paymentAccountsAsObservable.remove(paymentAccount);
if (changed) if (changed)
persist(); requestPersistence();
} }
public boolean addAcceptedArbitrator(Arbitrator arbitrator) { public boolean addAcceptedArbitrator(Arbitrator arbitrator) {
final List<Arbitrator> arbitrators = userPayload.getAcceptedArbitrators(); List<Arbitrator> arbitrators = userPayload.getAcceptedArbitrators();
if (arbitrators != null && !arbitrators.contains(arbitrator) && !isMyOwnRegisteredArbitrator(arbitrator)) { if (arbitrators != null && !arbitrators.contains(arbitrator) && !isMyOwnRegisteredArbitrator(arbitrator)) {
boolean changed = arbitrators.add(arbitrator); arbitrators.add(arbitrator);
if (changed) requestPersistence();
persist(); return true;
return changed;
} else { } else {
return false; return false;
} }
@ -237,24 +243,23 @@ public class User implements PersistedDataHost {
if (userPayload.getAcceptedArbitrators() != null) { if (userPayload.getAcceptedArbitrators() != null) {
boolean changed = userPayload.getAcceptedArbitrators().remove(arbitrator); boolean changed = userPayload.getAcceptedArbitrators().remove(arbitrator);
if (changed) if (changed)
persist(); requestPersistence();
} }
} }
public void clearAcceptedArbitrators() { public void clearAcceptedArbitrators() {
if (userPayload.getAcceptedArbitrators() != null) { if (userPayload.getAcceptedArbitrators() != null) {
userPayload.getAcceptedArbitrators().clear(); userPayload.getAcceptedArbitrators().clear();
persist(); requestPersistence();
} }
} }
public boolean addAcceptedMediator(Mediator mediator) { public boolean addAcceptedMediator(Mediator mediator) {
final List<Mediator> mediators = userPayload.getAcceptedMediators(); List<Mediator> mediators = userPayload.getAcceptedMediators();
if (mediators != null && !mediators.contains(mediator) && !isMyOwnRegisteredMediator(mediator)) { if (mediators != null && !mediators.contains(mediator) && !isMyOwnRegisteredMediator(mediator)) {
boolean changed = mediators.add(mediator); mediators.add(mediator);
if (changed) requestPersistence();
persist(); return true;
return changed;
} else { } else {
return false; return false;
} }
@ -264,24 +269,23 @@ public class User implements PersistedDataHost {
if (userPayload.getAcceptedMediators() != null) { if (userPayload.getAcceptedMediators() != null) {
boolean changed = userPayload.getAcceptedMediators().remove(mediator); boolean changed = userPayload.getAcceptedMediators().remove(mediator);
if (changed) if (changed)
persist(); requestPersistence();
} }
} }
public void clearAcceptedMediators() { public void clearAcceptedMediators() {
if (userPayload.getAcceptedMediators() != null) { if (userPayload.getAcceptedMediators() != null) {
userPayload.getAcceptedMediators().clear(); userPayload.getAcceptedMediators().clear();
persist(); requestPersistence();
} }
} }
public boolean addAcceptedRefundAgent(RefundAgent refundAgent) { public boolean addAcceptedRefundAgent(RefundAgent refundAgent) {
final List<RefundAgent> refundAgents = userPayload.getAcceptedRefundAgents(); List<RefundAgent> refundAgents = userPayload.getAcceptedRefundAgents();
if (refundAgents != null && !refundAgents.contains(refundAgent) && !isMyOwnRegisteredRefundAgent(refundAgent)) { if (refundAgents != null && !refundAgents.contains(refundAgent) && !isMyOwnRegisteredRefundAgent(refundAgent)) {
boolean changed = refundAgents.add(refundAgent); refundAgents.add(refundAgent);
if (changed) requestPersistence();
persist(); return true;
return changed;
} else { } else {
return false; return false;
} }
@ -291,14 +295,14 @@ public class User implements PersistedDataHost {
if (userPayload.getAcceptedRefundAgents() != null) { if (userPayload.getAcceptedRefundAgents() != null) {
boolean changed = userPayload.getAcceptedRefundAgents().remove(refundAgent); boolean changed = userPayload.getAcceptedRefundAgents().remove(refundAgent);
if (changed) if (changed)
persist(); requestPersistence();
} }
} }
public void clearAcceptedRefundAgents() { public void clearAcceptedRefundAgents() {
if (userPayload.getAcceptedRefundAgents() != null) { if (userPayload.getAcceptedRefundAgents() != null) {
userPayload.getAcceptedRefundAgents().clear(); userPayload.getAcceptedRefundAgents().clear();
persist(); requestPersistence();
} }
} }
@ -309,57 +313,57 @@ public class User implements PersistedDataHost {
public void setCurrentPaymentAccount(PaymentAccount paymentAccount) { public void setCurrentPaymentAccount(PaymentAccount paymentAccount) {
currentPaymentAccountProperty.set(paymentAccount); currentPaymentAccountProperty.set(paymentAccount);
persist(); requestPersistence();
} }
public void setRegisteredArbitrator(@Nullable Arbitrator arbitrator) { public void setRegisteredArbitrator(@Nullable Arbitrator arbitrator) {
userPayload.setRegisteredArbitrator(arbitrator); userPayload.setRegisteredArbitrator(arbitrator);
persist(); requestPersistence();
} }
public void setRegisteredMediator(@Nullable Mediator mediator) { public void setRegisteredMediator(@Nullable Mediator mediator) {
userPayload.setRegisteredMediator(mediator); userPayload.setRegisteredMediator(mediator);
persist(); requestPersistence();
} }
public void setRegisteredRefundAgent(@Nullable RefundAgent refundAgent) { public void setRegisteredRefundAgent(@Nullable RefundAgent refundAgent) {
userPayload.setRegisteredRefundAgent(refundAgent); userPayload.setRegisteredRefundAgent(refundAgent);
persist(); requestPersistence();
} }
public void setDevelopersFilter(@Nullable Filter developersFilter) { public void setDevelopersFilter(@Nullable Filter developersFilter) {
userPayload.setDevelopersFilter(developersFilter); userPayload.setDevelopersFilter(developersFilter);
persist(); requestPersistence();
} }
public void setDevelopersAlert(@Nullable Alert developersAlert) { public void setDevelopersAlert(@Nullable Alert developersAlert) {
userPayload.setDevelopersAlert(developersAlert); userPayload.setDevelopersAlert(developersAlert);
persist(); requestPersistence();
} }
public void setDisplayedAlert(@Nullable Alert displayedAlert) { public void setDisplayedAlert(@Nullable Alert displayedAlert) {
userPayload.setDisplayedAlert(displayedAlert); userPayload.setDisplayedAlert(displayedAlert);
persist(); requestPersistence();
} }
public void addMarketAlertFilter(MarketAlertFilter filter) { public void addMarketAlertFilter(MarketAlertFilter filter) {
getMarketAlertFilters().add(filter); getMarketAlertFilters().add(filter);
persist(); requestPersistence();
} }
public void removeMarketAlertFilter(MarketAlertFilter filter) { public void removeMarketAlertFilter(MarketAlertFilter filter) {
getMarketAlertFilters().remove(filter); getMarketAlertFilters().remove(filter);
persist(); requestPersistence();
} }
public void setPriceAlertFilter(PriceAlertFilter filter) { public void setPriceAlertFilter(PriceAlertFilter filter) {
userPayload.setPriceAlertFilter(filter); userPayload.setPriceAlertFilter(filter);
persist(); requestPersistence();
} }
public void removePriceAlertFilter() { public void removePriceAlertFilter() {
userPayload.setPriceAlertFilter(null); userPayload.setPriceAlertFilter(null);
persist(); requestPersistence();
} }
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
@ -378,10 +382,6 @@ public class User implements PersistedDataHost {
return userPayload.getAccountId(); return userPayload.getAccountId();
} }
private PaymentAccount getCurrentPaymentAccount() {
return userPayload.getCurrentPaymentAccount();
}
public ReadOnlyObjectProperty<PaymentAccount> currentPaymentAccountProperty() { public ReadOnlyObjectProperty<PaymentAccount> currentPaymentAccountProperty() {
return currentPaymentAccountProperty; return currentPaymentAccountProperty;
} }
@ -395,7 +395,6 @@ public class User implements PersistedDataHost {
return paymentAccountsAsObservable; return paymentAccountsAsObservable;
} }
/** /**
* If this user is an arbitrator it returns the registered arbitrator. * If this user is an arbitrator it returns the registered arbitrator.
* *
@ -416,8 +415,6 @@ public class User implements PersistedDataHost {
return userPayload.getRegisteredRefundAgent(); return userPayload.getRegisteredRefundAgent();
} }
//TODO
@Nullable @Nullable
public List<Arbitrator> getAcceptedArbitrators() { public List<Arbitrator> getAcceptedArbitrators() {
return userPayload.getAcceptedArbitrators(); return userPayload.getAcceptedArbitrators();
@ -435,17 +432,23 @@ public class User implements PersistedDataHost {
@Nullable @Nullable
public List<NodeAddress> getAcceptedArbitratorAddresses() { public List<NodeAddress> getAcceptedArbitratorAddresses() {
return userPayload.getAcceptedArbitrators() != null ? userPayload.getAcceptedArbitrators().stream().map(Arbitrator::getNodeAddress).collect(Collectors.toList()) : null; return userPayload.getAcceptedArbitrators() != null ?
userPayload.getAcceptedArbitrators().stream().map(Arbitrator::getNodeAddress).collect(Collectors.toList()) :
null;
} }
@Nullable @Nullable
public List<NodeAddress> getAcceptedMediatorAddresses() { public List<NodeAddress> getAcceptedMediatorAddresses() {
return userPayload.getAcceptedMediators() != null ? userPayload.getAcceptedMediators().stream().map(Mediator::getNodeAddress).collect(Collectors.toList()) : null; return userPayload.getAcceptedMediators() != null ?
userPayload.getAcceptedMediators().stream().map(Mediator::getNodeAddress).collect(Collectors.toList()) :
null;
} }
@Nullable @Nullable
public List<NodeAddress> getAcceptedRefundAgentAddresses() { public List<NodeAddress> getAcceptedRefundAgentAddresses() {
return userPayload.getAcceptedRefundAgents() != null ? userPayload.getAcceptedRefundAgents().stream().map(RefundAgent::getNodeAddress).collect(Collectors.toList()) : null; return userPayload.getAcceptedRefundAgents() != null ?
userPayload.getAcceptedRefundAgents().stream().map(RefundAgent::getNodeAddress).collect(Collectors.toList()) :
null;
} }
public boolean hasAcceptedArbitrators() { public boolean hasAcceptedArbitrators() {