Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-06-20 04:44:30 -04:00
Code Issues Projects Releases Packages Wiki Activity

Remove unneeded state handlers and views

Browse source
This commit is contained in:
Manfred Karrer 2015-04-03 13:14:18 +02:00
parent 31ba7882f7
commit 3a95e51bc9
9 changed files with 207 additions and 539 deletions
Download patch file Download diff file Expand all files Collapse all files

15
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/TakerAsBuyerSubView.java → core/src/main/java/io/bitsquare/gui/main/portfolio/pending/BuyerSubView.java
View file

@ -28,9 +28,8 @@ import io.bitsquare.locale.BSResources;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerAsBuyerSubView extends TradeSubView { public class BuyerSubView extends TradeSubView {
private static final Logger log = LoggerFactory.getLogger(TakerAsBuyerSubView.class); private static final Logger log = LoggerFactory.getLogger(BuyerSubView.class);
private TradeWizardItem waitTxInBlockchain; private TradeWizardItem waitTxInBlockchain;
private TradeWizardItem startFiat; private TradeWizardItem startFiat;
@ -42,7 +41,7 @@ public class TakerAsBuyerSubView extends TradeSubView {
// Constructor, Initialisation // Constructor, Initialisation
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public TakerAsBuyerSubView(PendingTradesViewModel model) { public BuyerSubView(PendingTradesViewModel model) {
super(model); super(model);
} }
@ -83,7 +82,7 @@ public class TakerAsBuyerSubView extends TradeSubView {
switch (viewState) { switch (viewState) {
case EMPTY: case EMPTY:
break; break;
case TAKER_BUYER_WAIT_TX_CONF: case BUYER_WAIT_TX_CONF:
showItem(waitTxInBlockchain); showItem(waitTxInBlockchain);
((WaitTxInBlockchainView) tradeStepDetailsView).setInfoLabelText("Deposit transaction has been published. You need to wait for at least " + ((WaitTxInBlockchainView) tradeStepDetailsView).setInfoLabelText("Deposit transaction has been published. You need to wait for at least " +
@ -92,11 +91,11 @@ public class TakerAsBuyerSubView extends TradeSubView {
" be sure that the deposit funding has not been double spent. For higher trade volumes we" + " be sure that the deposit funding has not been double spent. For higher trade volumes we" +
" recommend to wait up to 6 confirmations."); " recommend to wait up to 6 confirmations.");
break; break;
case TAKER_BUYER_START_PAYMENT: case BUYER_START_PAYMENT:
waitTxInBlockchain.done(); waitTxInBlockchain.done();
showItem(startFiat); showItem(startFiat);
break; break;
case TAKER_BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED: case BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED:
waitTxInBlockchain.done(); waitTxInBlockchain.done();
startFiat.done(); startFiat.done();
showItem(waitFiatReceived); showItem(waitFiatReceived);
@ -108,7 +107,7 @@ public class TakerAsBuyerSubView extends TradeSubView {
"the Bitcoin sellers payment account, the payout transaction will be published.", "the Bitcoin sellers payment account, the payout transaction will be published.",
model.getCurrencyCode())); model.getCurrencyCode()));
break; break;
case TAKER_BUYER_COMPLETED: case BUYER_COMPLETED:
waitTxInBlockchain.done(); waitTxInBlockchain.done();
startFiat.done(); startFiat.done();
waitFiatReceived.done(); waitFiatReceived.done();

145
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/OffererAsBuyerSubView.java
View file

@ -1,145 +0,0 @@
/*
* This file is part of Bitsquare.
*
* Bitsquare is free software: you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or (at
* your option) any later version.
*
* Bitsquare 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 Affero General Public
* License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/
package io.bitsquare.gui.main.portfolio.pending;
import io.bitsquare.gui.components.Popups;
import io.bitsquare.gui.main.portfolio.pending.steps.CompletedView;
import io.bitsquare.gui.main.portfolio.pending.steps.StartFiatView;
import io.bitsquare.gui.main.portfolio.pending.steps.TradeWizardItem;
import io.bitsquare.gui.main.portfolio.pending.steps.WaitFiatReceivedView;
import io.bitsquare.gui.main.portfolio.pending.steps.WaitTxInBlockchainView;
import io.bitsquare.locale.BSResources;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererAsBuyerSubView extends TradeSubView {
private static final Logger log = LoggerFactory.getLogger(OffererAsBuyerSubView.class);
private TradeWizardItem waitTxInBlockchain;
private TradeWizardItem startFiat;
private TradeWizardItem waitFiatReceived;
private TradeWizardItem completed;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor, Initialisation
///////////////////////////////////////////////////////////////////////////////////////////
public OffererAsBuyerSubView(PendingTradesViewModel model) {
super(model);
}
@Override
public void activate() {
super.activate();
}
@Override
public void deactivate() {
super.deactivate();
}
@Override
protected void addWizards() {
waitTxInBlockchain = new TradeWizardItem(WaitTxInBlockchainView.class, "Wait for blockchain confirmation");
startFiat = new TradeWizardItem(StartFiatView.class, "Start payment");
waitFiatReceived = new TradeWizardItem(WaitFiatReceivedView.class, "Wait until payment has arrived");
completed = new TradeWizardItem(CompletedView.class, "Completed");
leftVBox.getChildren().addAll(waitTxInBlockchain, startFiat, waitFiatReceived, completed);
}
///////////////////////////////////////////////////////////////////////////////////////////
// State
///////////////////////////////////////////////////////////////////////////////////////////
@Override
protected void applyState(PendingTradesViewModel.ViewState viewState) {
log.debug("applyState " + viewState);
waitTxInBlockchain.inactive();
startFiat.inactive();
waitFiatReceived.inactive();
completed.inactive();
switch (viewState) {
case EMPTY:
break;
case OFFERER_BUYER_WAIT_TX_CONF:
showItem(waitTxInBlockchain);
((WaitTxInBlockchainView) tradeStepDetailsView).setInfoLabelText("Deposit transaction has been published. You need to wait for at least " +
"one block chain confirmation.");
((WaitTxInBlockchainView) tradeStepDetailsView).setInfoDisplayField("You need to wait for at least one block chain confirmation to" +
" be sure that the deposit funding has not been double spent. For higher trade volumes we" +
" recommend to wait up to 6 confirmations.");
break;
case OFFERER_BUYER_START_PAYMENT:
waitTxInBlockchain.done();
showItem(startFiat);
break;
case OFFERER_BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED:
waitTxInBlockchain.done();
startFiat.done();
showItem(waitFiatReceived);
((WaitFiatReceivedView) tradeStepDetailsView).setInfoLabelText(BSResources.get("Waiting for the Bitcoin sellers confirmation " +
"that the {0} payment has arrived.",
model.getCurrencyCode()));
((WaitFiatReceivedView) tradeStepDetailsView).setInfoDisplayField(BSResources.get("When the confirmation that the {0} payment arrived at " +
"the Bitcoin sellers payment account, the payout transaction will be published.",
model.getCurrencyCode()));
break;
case OFFERER_BUYER_COMPLETED:
waitTxInBlockchain.done();
startFiat.done();
waitFiatReceived.done();
showItem(completed);
CompletedView completedView = (CompletedView) tradeStepDetailsView;
completedView.setBtcTradeAmountLabelText("You have bought:");
completedView.setFiatTradeAmountLabelText("You have paid:");
completedView.setBtcTradeAmountTextFieldText(model.getTradeVolume());
completedView.setFiatTradeAmountTextFieldText(model.getFiatVolume());
completedView.setFeesTextFieldText(model.getTotalFees());
completedView.setSecurityDepositTextFieldText(model.getSecurityDeposit());
completedView.setSummaryInfoDisplayText("Your security deposit has been refunded to you. " +
"You can review the details to that trade any time in the closed trades screen.");
completedView.setWithdrawAmountTextFieldText(model.getPayoutAmount());
break;
case MESSAGE_SENDING_FAILED:
Popups.openWarningPopup("Sending message to trading peer failed.", model.getErrorMessage());
break;
case EXCEPTION:
if (model.getTradeException() != null)
Popups.openExceptionPopup(model.getTradeException());
break;
default:
log.warn("unhandled viewState " + viewState);
break;
}
if (tradeStepDetailsView != null)
tradeStepDetailsView.activate();
}
}

158
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/OffererAsSellerSubView.java
View file

@ -1,158 +0,0 @@
/*
* This file is part of Bitsquare.
*
* Bitsquare is free software: you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or (at
* your option) any later version.
*
* Bitsquare 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 Affero General Public
* License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with Bitsquare. If not, see <http://www.gnu.org/licenses/>.
*/
package io.bitsquare.gui.main.portfolio.pending;
import io.bitsquare.gui.components.Popups;
import io.bitsquare.gui.main.portfolio.pending.steps.CompletedView;
import io.bitsquare.gui.main.portfolio.pending.steps.ConfirmFiatReceivedView;
import io.bitsquare.gui.main.portfolio.pending.steps.TradeWizardItem;
import io.bitsquare.gui.main.portfolio.pending.steps.WaitTxInBlockchainView;
import io.bitsquare.locale.BSResources;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OffererAsSellerSubView extends TradeSubView {
private static final Logger log = LoggerFactory.getLogger(OffererAsSellerSubView.class);
private TradeWizardItem waitTxInBlockchain;
private TradeWizardItem waitFiatStarted;
private TradeWizardItem confirmFiatReceived;
private TradeWizardItem completed;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor, Initialisation
///////////////////////////////////////////////////////////////////////////////////////////
public OffererAsSellerSubView(PendingTradesViewModel model) {
super(model);
}
@Override
public void activate() {
super.activate();
}
@Override
public void deactivate() {
super.deactivate();
}
@Override
protected void addWizards() {
waitTxInBlockchain = new TradeWizardItem(WaitTxInBlockchainView.class, "Wait for blockchain confirmation");
waitFiatStarted = new TradeWizardItem(WaitTxInBlockchainView.class, "Wait for payment started");
confirmFiatReceived = new TradeWizardItem(ConfirmFiatReceivedView.class, "Confirm payment received");
completed = new TradeWizardItem(CompletedView.class, "Completed");
leftVBox.getChildren().addAll(waitTxInBlockchain, waitFiatStarted, confirmFiatReceived, completed);
}
///////////////////////////////////////////////////////////////////////////////////////////
// State
///////////////////////////////////////////////////////////////////////////////////////////
@Override
protected void applyState(PendingTradesViewModel.ViewState viewState) {
log.debug("applyState " + viewState);
waitTxInBlockchain.inactive();
waitFiatStarted.inactive();
confirmFiatReceived.inactive();
completed.inactive();
switch (viewState) {
case EMPTY:
break;
case OFFERER_SELLER_WAIT_TX_CONF:
showItem(waitTxInBlockchain);
((WaitTxInBlockchainView) tradeStepDetailsView).setInfoLabelText("Deposit transaction has been published. " +
"The Bitcoin buyer need to wait for at least one block chain confirmation.");
((WaitTxInBlockchainView) tradeStepDetailsView).setInfoDisplayField(BSResources.get("The Bitcoin buyer needs to wait for at least one " +
"block chain confirmation before starting the {0} payment. " +
"That is needed to assure that the deposit input funding has not been " +
"double-spent. " +
"For higher trade volumes it is recommended to wait up to 6 confirmations.",
model.getCurrencyCode()));
break;
case OFFERER_SELLER_WAIT_PAYMENT_STARTED:
waitTxInBlockchain.done();
showItem(waitFiatStarted);
((WaitTxInBlockchainView) tradeStepDetailsView).setInfoLabelText(BSResources.get("Deposit transaction has at least one block chain " +
"confirmation. " +
"Waiting that other trader starts the {0} payment.",
model.getCurrencyCode()));
((WaitTxInBlockchainView) tradeStepDetailsView).setInfoDisplayField(BSResources.get("You will get informed when the other trader has " +
"indicated the {0} payment has been started.",
model.getCurrencyCode()));
break;
case OFFERER_SELLER_CONFIRM_RECEIVE_PAYMENT:
waitTxInBlockchain.done();
waitFiatStarted.done();
showItem(confirmFiatReceived);
((ConfirmFiatReceivedView) tradeStepDetailsView).setInfoLabelText(BSResources.get("The Bitcoin buyer has started the {0} payment." +
"Check your payments account and confirm when you have received the payment.",
model.getCurrencyCode()));
((ConfirmFiatReceivedView) tradeStepDetailsView).setInfoDisplayField(BSResources.get("It is important that you confirm when you have " +
"received the {0} payment as this will publish the payout transaction where you get returned " +
"your security deposit and the Bitcoin buyer receive the Bitcoin amount you sold.",
model.getCurrencyCode()));
break;
case OFFERER_SELLER_COMPLETED:
waitTxInBlockchain.done();
waitFiatStarted.done();
confirmFiatReceived.done();
showItem(completed);
CompletedView completedView = (CompletedView) tradeStepDetailsView;
completedView.setBtcTradeAmountLabelText("You have sold:");
completedView.setFiatTradeAmountLabelText("You have received:");
completedView.setBtcTradeAmountTextFieldText(model.getTradeVolume());
completedView.setFiatTradeAmountTextFieldText(model.getFiatVolume());
completedView.setFeesTextFieldText(model.getTotalFees());
completedView.setSecurityDepositTextFieldText(model.getSecurityDeposit());
completedView.setSummaryInfoDisplayText("Your security deposit has been refunded to you. " +
"You can review the details to that trade any time in the closed trades screen.");
completedView.setWithdrawAmountTextFieldText(model.getPayoutAmount());
break;
case MESSAGE_SENDING_FAILED:
Popups.openWarningPopup("Sending message to trading peer failed.", model.getErrorMessage());
break;
case EXCEPTION:
if (model.getTradeException() != null)
Popups.openExceptionPopup(model.getTradeException());
break;
default:
log.warn("unhandled viewState " + viewState);
break;
}
if (tradeStepDetailsView != null)
tradeStepDetailsView.activate();
}
}

29
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/PendingTradesDataModel.java
View file

@ -23,12 +23,8 @@ import io.bitsquare.common.viewfx.model.Activatable;
import io.bitsquare.common.viewfx.model.DataModel; import io.bitsquare.common.viewfx.model.DataModel;
import io.bitsquare.gui.components.Popups; import io.bitsquare.gui.components.Popups;
import io.bitsquare.offer.Offer; import io.bitsquare.offer.Offer;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.BuyerTrade; import io.bitsquare.trade.BuyerTrade;
import io.bitsquare.trade.Contract; import io.bitsquare.trade.Contract;
import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.SellerTrade; import io.bitsquare.trade.SellerTrade;
import io.bitsquare.trade.Trade; import io.bitsquare.trade.Trade;
import io.bitsquare.trade.TradeManager; import io.bitsquare.trade.TradeManager;
@ -71,10 +67,8 @@ class PendingTradesDataModel implements Activatable, DataModel {
final StringProperty txId = new SimpleStringProperty(); final StringProperty txId = new SimpleStringProperty();
final IntegerProperty selectedIndex = new SimpleIntegerProperty(-1); final IntegerProperty selectedIndex = new SimpleIntegerProperty(-1);
final ObjectProperty<TradeState.ProcessState> takerAsSellerProcessState = new SimpleObjectProperty<>(); final ObjectProperty<TradeState.ProcessState> sellerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<TradeState.ProcessState> offererAsBuyerProcessState = new SimpleObjectProperty<>(); final ObjectProperty<TradeState.ProcessState> buyerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<TradeState.ProcessState> takerAsBuyerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<TradeState.ProcessState> offererAsSellerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<Trade> currentTrade = new SimpleObjectProperty<>(); final ObjectProperty<Trade> currentTrade = new SimpleObjectProperty<>();
@ -139,15 +133,10 @@ class PendingTradesDataModel implements Activatable, DataModel {
Trade trade = item.getTrade(); Trade trade = item.getTrade();
isOfferer = trade.getOffer().getP2pSigPubKey().equals(user.getP2pSigPubKey()); isOfferer = trade.getOffer().getP2pSigPubKey().equals(user.getP2pSigPubKey());
// TODO merge states if (trade instanceof SellerTrade)
if (trade instanceof SellerAsTakerTrade) sellerProcessState.bind(trade.processStateProperty());
takerAsSellerProcessState.bind(trade.processStateProperty()); else if (trade instanceof BuyerTrade)
else if (trade instanceof BuyerAsOffererTrade) buyerProcessState.bind(trade.processStateProperty());
offererAsBuyerProcessState.bind(trade.processStateProperty());
else if (trade instanceof BuyerAsTakerTrade)
takerAsBuyerProcessState.bind(trade.processStateProperty());
else if (trade instanceof SellerAsOffererTrade)
offererAsSellerProcessState.bind(trade.processStateProperty());
if (trade.getDepositTx() != null) if (trade.getDepositTx() != null)
txId.set(trade.getDepositTx().getHashAsString()); txId.set(trade.getDepositTx().getHashAsString());
@ -253,10 +242,8 @@ class PendingTradesDataModel implements Activatable, DataModel {
} }
private void unbindStates() { private void unbindStates() {
takerAsSellerProcessState.unbind(); sellerProcessState.unbind();
takerAsBuyerProcessState.unbind(); buyerProcessState.unbind();
offererAsBuyerProcessState.unbind();
offererAsSellerProcessState.unbind();
} }
public Coin getPayoutAmount() { public Coin getPayoutAmount() {

8
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/PendingTradesView.java
View file

@ -129,15 +129,15 @@ public class PendingTradesView extends ActivatableViewAndModel<VBox, PendingTrad
if (model.isOfferer()) { if (model.isOfferer()) {
if (model.isBuyOffer()) if (model.isBuyOffer())
currentSubView = new OffererAsBuyerSubView(model); currentSubView = new BuyerSubView(model);
else else
currentSubView = new OffererAsSellerSubView(model); currentSubView = new SellerSubView(model);
} }
else { else {
if (model.isBuyOffer()) if (model.isBuyOffer())
currentSubView = new TakerAsSellerSubView(model); currentSubView = new SellerSubView(model);
else else
currentSubView = new TakerAsBuyerSubView(model); currentSubView = new BuyerSubView(model);
} }
currentSubView.activate(); currentSubView.activate();

343
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/PendingTradesViewModel.java
View file

@ -57,25 +57,15 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
enum ViewState { enum ViewState {
EMPTY, EMPTY,
TAKER_SELLER_WAIT_TX_CONF, SELLER_WAIT_TX_CONF,
TAKER_SELLER_WAIT_PAYMENT_STARTED, SELLER_WAIT_PAYMENT_STARTED,
TAKER_SELLER_CONFIRM_RECEIVE_PAYMENT, SELLER_CONFIRM_RECEIVE_PAYMENT,
TAKER_SELLER_COMPLETED, SELLER_COMPLETED,
OFFERER_BUYER_WAIT_TX_CONF, BUYER_WAIT_TX_CONF,
OFFERER_BUYER_START_PAYMENT, BUYER_START_PAYMENT,
OFFERER_BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED, BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED,
OFFERER_BUYER_COMPLETED, BUYER_COMPLETED,
TAKER_BUYER_WAIT_TX_CONF,
TAKER_BUYER_START_PAYMENT,
TAKER_BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED,
TAKER_BUYER_COMPLETED,
OFFERER_SELLER_WAIT_TX_CONF,
OFFERER_SELLER_WAIT_PAYMENT_STARTED,
OFFERER_SELLER_CONFIRM_RECEIVE_PAYMENT,
OFFERER_SELLER_COMPLETED,
MESSAGE_SENDING_FAILED, MESSAGE_SENDING_FAILED,
EXCEPTION EXCEPTION
@ -83,10 +73,8 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
private Navigation navigation; private Navigation navigation;
private final BSFormatter formatter; private final BSFormatter formatter;
private final InvalidationListener takerAsSellerStateListener; private final InvalidationListener sellerStateListener;
private final InvalidationListener offererAsBuyerStateListener; private final InvalidationListener buyerStateListener;
private final InvalidationListener takerAsBuyerStateListener;
private final InvalidationListener offererAsSellerStateListener;
private final BtcAddressValidator btcAddressValidator; private final BtcAddressValidator btcAddressValidator;
@ -105,10 +93,8 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
this.formatter = formatter; this.formatter = formatter;
this.btcAddressValidator = btcAddressValidator; this.btcAddressValidator = btcAddressValidator;
this.takerAsSellerStateListener = (ov) -> updateTakerAsSellerState(); this.sellerStateListener = (ov) -> updateSellerState();
this.offererAsBuyerStateListener = (ov) -> updateOffererAsBuyerState(); this.buyerStateListener = (ov) -> updateBuyerState();
this.takerAsBuyerStateListener = (ov) -> updateTakerAsBuyerState();
this.offererAsSellerStateListener = (ov) -> updateOffererAsSellerState();
} }
@Override @Override
@ -116,15 +102,11 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
txId.bind(dataModel.txId); txId.bind(dataModel.txId);
selectedIndex.bind(dataModel.selectedIndex); selectedIndex.bind(dataModel.selectedIndex);
dataModel.takerAsSellerProcessState.addListener(takerAsSellerStateListener); dataModel.sellerProcessState.addListener(sellerStateListener);
dataModel.offererAsBuyerProcessState.addListener(offererAsBuyerStateListener); dataModel.buyerProcessState.addListener(buyerStateListener);
dataModel.takerAsBuyerProcessState.addListener(takerAsBuyerStateListener);
dataModel.offererAsSellerProcessState.addListener(offererAsSellerStateListener);
updateTakerAsSellerState(); updateSellerState();
updateOffererAsBuyerState(); updateBuyerState();
updateTakerAsBuyerState();
updateOffererAsSellerState();
} }
@Override @Override
@ -132,10 +114,8 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
txId.unbind(); txId.unbind();
selectedIndex.unbind(); selectedIndex.unbind();
dataModel.takerAsSellerProcessState.removeListener(takerAsSellerStateListener); dataModel.sellerProcessState.removeListener(sellerStateListener);
dataModel.offererAsBuyerProcessState.removeListener(offererAsBuyerStateListener); dataModel.buyerProcessState.removeListener(buyerStateListener);
dataModel.takerAsBuyerProcessState.removeListener(takerAsBuyerStateListener);
dataModel.offererAsSellerProcessState.removeListener(offererAsSellerStateListener);
} }
@ -273,163 +253,168 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
return dataModel.getErrorMessage(); return dataModel.getErrorMessage();
} }
private void updateTakerAsSellerState() { private void updateSellerState() {
TakerTradeState.ProcessState processState = (TakerTradeState.ProcessState) dataModel.takerAsSellerProcessState.get(); if (dataModel.sellerProcessState.get() instanceof TakerTradeState.ProcessState) {
log.debug("updateTakerAsSellerState " + processState); TakerTradeState.ProcessState processState = (TakerTradeState.ProcessState) dataModel.sellerProcessState.get();
if (processState != null) { log.debug("updateSellerState (TakerTradeState) " + processState);
switch (processState) { if (processState != null) {
case UNDEFINED: switch (processState) {
case TAKE_OFFER_FEE_TX_CREATED: case UNDEFINED:
case TAKE_OFFER_FEE_PUBLISHED: case TAKE_OFFER_FEE_TX_CREATED:
break; case TAKE_OFFER_FEE_PUBLISHED:
case TAKE_OFFER_FEE_PUBLISH_FAILED: break;
viewState.set(ViewState.EXCEPTION); case TAKE_OFFER_FEE_PUBLISH_FAILED:
break; viewState.set(ViewState.EXCEPTION);
break;
case DEPOSIT_PUBLISHED: case DEPOSIT_PUBLISHED:
viewState.set(ViewState.TAKER_SELLER_WAIT_TX_CONF); viewState.set(ViewState.SELLER_WAIT_TX_CONF);
break; break;
case DEPOSIT_CONFIRMED: case DEPOSIT_CONFIRMED:
viewState.set(ViewState.TAKER_SELLER_WAIT_PAYMENT_STARTED); viewState.set(ViewState.SELLER_WAIT_PAYMENT_STARTED);
break; break;
case FIAT_PAYMENT_STARTED: case FIAT_PAYMENT_STARTED:
viewState.set(ViewState.TAKER_SELLER_CONFIRM_RECEIVE_PAYMENT); viewState.set(ViewState.SELLER_CONFIRM_RECEIVE_PAYMENT);
break; break;
case FIAT_PAYMENT_RECEIVED: case FIAT_PAYMENT_RECEIVED:
case PAYOUT_PUBLISHED: case PAYOUT_PUBLISHED:
viewState.set(ViewState.TAKER_SELLER_COMPLETED); viewState.set(ViewState.SELLER_COMPLETED);
break; break;
case MESSAGE_SENDING_FAILED: case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED); viewState.set(ViewState.MESSAGE_SENDING_FAILED);
break; break;
case EXCEPTION: case EXCEPTION:
viewState.set(ViewState.EXCEPTION); viewState.set(ViewState.EXCEPTION);
break; break;
default: default:
log.warn("unhandled processState " + processState); log.warn("unhandled processState " + processState);
break; break;
}
}
}
else if (dataModel.sellerProcessState.get() instanceof OffererTradeState.ProcessState) {
OffererTradeState.ProcessState processState = (OffererTradeState.ProcessState) dataModel.sellerProcessState.get();
log.debug("updateSellerState (OffererTradeState) " + processState);
if (processState != null) {
switch (processState) {
case UNDEFINED:
break;
case DEPOSIT_PUBLISHED:
viewState.set(ViewState.SELLER_WAIT_TX_CONF);
break;
case DEPOSIT_CONFIRMED:
viewState.set(ViewState.SELLER_WAIT_PAYMENT_STARTED);
break;
case FIAT_PAYMENT_STARTED:
viewState.set(ViewState.SELLER_CONFIRM_RECEIVE_PAYMENT);
break;
case FIAT_PAYMENT_RECEIVED:
case PAYOUT_PUBLISHED:
viewState.set(ViewState.SELLER_COMPLETED);
break;
case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED);
break;
case EXCEPTION:
viewState.set(ViewState.EXCEPTION);
break;
default:
log.warn("unhandled processState " + processState);
break;
}
} }
} }
} }
private void updateOffererAsBuyerState() { private void updateBuyerState() {
OffererTradeState.ProcessState processState = (OffererTradeState.ProcessState) dataModel.offererAsBuyerProcessState.get(); if (dataModel.buyerProcessState.get() instanceof TakerTradeState.ProcessState) {
log.debug("updateOffererAsBuyerState " + processState); TakerTradeState.ProcessState processState = (TakerTradeState.ProcessState) dataModel.buyerProcessState.get();
if (processState != null) { log.debug("updateBuyerState (TakerTradeState)" + processState);
switch (processState) { if (processState != null) {
case UNDEFINED: switch (processState) {
break; case UNDEFINED:
case DEPOSIT_PUBLISHED: case TAKE_OFFER_FEE_TX_CREATED:
viewState.set(ViewState.OFFERER_BUYER_WAIT_TX_CONF); case TAKE_OFFER_FEE_PUBLISHED:
break; break;
case DEPOSIT_CONFIRMED: case TAKE_OFFER_FEE_PUBLISH_FAILED:
viewState.set(ViewState.OFFERER_BUYER_START_PAYMENT); viewState.set(ViewState.EXCEPTION);
break; break;
case FIAT_PAYMENT_STARTED: case DEPOSIT_PUBLISHED:
viewState.set(ViewState.OFFERER_BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED); viewState.set(ViewState.BUYER_WAIT_TX_CONF);
break; break;
case DEPOSIT_CONFIRMED:
viewState.set(ViewState.BUYER_START_PAYMENT);
break;
case PAYOUT_PUBLISHED: case FIAT_PAYMENT_STARTED:
viewState.set(ViewState.OFFERER_BUYER_COMPLETED); viewState.set(ViewState.BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED);
break; break;
case MESSAGE_SENDING_FAILED: case FIAT_PAYMENT_RECEIVED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED); case PAYOUT_PUBLISHED:
break; viewState.set(ViewState.BUYER_COMPLETED);
case EXCEPTION: break;
viewState.set(ViewState.EXCEPTION);
break;
default: case MESSAGE_SENDING_FAILED:
log.warn("unhandled viewState " + processState); viewState.set(ViewState.MESSAGE_SENDING_FAILED);
break; break;
case EXCEPTION:
viewState.set(ViewState.EXCEPTION);
break;
default:
log.warn("unhandled viewState " + processState);
break;
}
}
}
else if (dataModel.buyerProcessState.get() instanceof OffererTradeState.ProcessState) {
OffererTradeState.ProcessState processState = (OffererTradeState.ProcessState) dataModel.buyerProcessState.get();
log.debug("updateBuyerState (OffererTradeState) " + processState);
if (processState != null) {
switch (processState) {
case UNDEFINED:
break;
case DEPOSIT_PUBLISHED:
viewState.set(ViewState.BUYER_WAIT_TX_CONF);
break;
case DEPOSIT_CONFIRMED:
viewState.set(ViewState.BUYER_START_PAYMENT);
break;
case FIAT_PAYMENT_STARTED:
viewState.set(ViewState.BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED);
break;
case FIAT_PAYMENT_RECEIVED:
case PAYOUT_PUBLISHED:
viewState.set(ViewState.BUYER_COMPLETED);
break;
case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED);
break;
case EXCEPTION:
viewState.set(ViewState.EXCEPTION);
break;
default:
log.warn("unhandled viewState " + processState);
break;
}
} }
} }
} }
private void updateTakerAsBuyerState() {
TakerTradeState.ProcessState processState = (TakerTradeState.ProcessState) dataModel.takerAsBuyerProcessState.get();
log.debug("updateTakerAsBuyerState " + processState);
if (processState != null) {
switch (processState) {
case UNDEFINED:
case TAKE_OFFER_FEE_TX_CREATED:
case TAKE_OFFER_FEE_PUBLISHED:
break;
case TAKE_OFFER_FEE_PUBLISH_FAILED:
viewState.set(ViewState.EXCEPTION);
break;
case DEPOSIT_PUBLISHED:
viewState.set(ViewState.TAKER_BUYER_WAIT_TX_CONF);
break;
case DEPOSIT_CONFIRMED:
viewState.set(ViewState.TAKER_BUYER_START_PAYMENT);
break;
case FIAT_PAYMENT_STARTED:
viewState.set(ViewState.TAKER_BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED);
break;
case FIAT_PAYMENT_RECEIVED:
case PAYOUT_PUBLISHED:
viewState.set(ViewState.TAKER_BUYER_COMPLETED);
break;
case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED);
break;
case EXCEPTION:
viewState.set(ViewState.EXCEPTION);
break;
default:
log.warn("unhandled viewState " + processState);
break;
}
}
}
private void updateOffererAsSellerState() {
OffererTradeState.ProcessState processState = (OffererTradeState.ProcessState) dataModel.offererAsSellerProcessState.get();
log.debug("updateOffererAsSellerState " + processState);
if (processState != null) {
switch (processState) {
case UNDEFINED:
break;
case DEPOSIT_PUBLISHED:
viewState.set(ViewState.OFFERER_SELLER_WAIT_TX_CONF);
break;
case DEPOSIT_CONFIRMED:
viewState.set(ViewState.OFFERER_SELLER_WAIT_PAYMENT_STARTED);
break;
case FIAT_PAYMENT_STARTED:
viewState.set(ViewState.OFFERER_SELLER_CONFIRM_RECEIVE_PAYMENT);
break;
case FIAT_PAYMENT_RECEIVED:
case PAYOUT_PUBLISHED:
viewState.set(ViewState.OFFERER_SELLER_COMPLETED);
break;
case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED);
break;
case EXCEPTION:
viewState.set(ViewState.EXCEPTION);
break;
default:
log.warn("unhandled processState " + processState);
break;
}
}
}
} }

14
core/src/main/java/io/bitsquare/gui/main/portfolio/pending/TakerAsSellerSubView.java → core/src/main/java/io/bitsquare/gui/main/portfolio/pending/SellerSubView.java
View file

@ -27,8 +27,8 @@ import io.bitsquare.locale.BSResources;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class TakerAsSellerSubView extends TradeSubView { public class SellerSubView extends TradeSubView {
private static final Logger log = LoggerFactory.getLogger(TakerAsSellerSubView.class); private static final Logger log = LoggerFactory.getLogger(SellerSubView.class);
private TradeWizardItem waitTxInBlockchain; private TradeWizardItem waitTxInBlockchain;
private TradeWizardItem waitFiatStarted; private TradeWizardItem waitFiatStarted;
@ -40,7 +40,7 @@ public class TakerAsSellerSubView extends TradeSubView {
// Constructor, Initialisation // Constructor, Initialisation
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
public TakerAsSellerSubView(PendingTradesViewModel model) { public SellerSubView(PendingTradesViewModel model) {
super(model); super(model);
} }
@ -81,7 +81,7 @@ public class TakerAsSellerSubView extends TradeSubView {
switch (viewState) { switch (viewState) {
case EMPTY: case EMPTY:
break; break;
case TAKER_SELLER_WAIT_TX_CONF: case SELLER_WAIT_TX_CONF:
showItem(waitTxInBlockchain); showItem(waitTxInBlockchain);
((WaitTxInBlockchainView) tradeStepDetailsView).setInfoLabelText("Deposit transaction has been published. " + ((WaitTxInBlockchainView) tradeStepDetailsView).setInfoLabelText("Deposit transaction has been published. " +
@ -93,7 +93,7 @@ public class TakerAsSellerSubView extends TradeSubView {
"For higher trade volumes it is recommended to wait up to 6 confirmations.", "For higher trade volumes it is recommended to wait up to 6 confirmations.",
model.getCurrencyCode())); model.getCurrencyCode()));
break; break;
case TAKER_SELLER_WAIT_PAYMENT_STARTED: case SELLER_WAIT_PAYMENT_STARTED:
waitTxInBlockchain.done(); waitTxInBlockchain.done();
showItem(waitFiatStarted); showItem(waitFiatStarted);
@ -106,7 +106,7 @@ public class TakerAsSellerSubView extends TradeSubView {
"the {0} payment has been started.", "the {0} payment has been started.",
model.getCurrencyCode())); model.getCurrencyCode()));
break; break;
case TAKER_SELLER_CONFIRM_RECEIVE_PAYMENT: case SELLER_CONFIRM_RECEIVE_PAYMENT:
waitTxInBlockchain.done(); waitTxInBlockchain.done();
waitFiatStarted.done(); waitFiatStarted.done();
showItem(confirmFiatReceived); showItem(confirmFiatReceived);
@ -121,7 +121,7 @@ public class TakerAsSellerSubView extends TradeSubView {
model.getCurrencyCode())); model.getCurrencyCode()));
break; break;
case TAKER_SELLER_COMPLETED: case SELLER_COMPLETED:
waitTxInBlockchain.done(); waitTxInBlockchain.done();
waitFiatStarted.done(); waitFiatStarted.done();
confirmFiatReceived.done(); confirmFiatReceived.done();

18
core/src/main/java/io/bitsquare/trade/protocol/trade/BuyerAsOffererProtocol.java
View file

@ -82,7 +82,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
if (processModel.getMailboxMessage() == null) { if (processModel.getMailboxMessage() == null) {
processModel.setMailboxMessage(mailboxMessage); processModel.setMailboxMessage(mailboxMessage);
if (mailboxMessage instanceof PayoutTxPublishedMessage) { if (mailboxMessage instanceof PayoutTxPublishedMessage) {
handlePayoutTxPublishedMessage((PayoutTxPublishedMessage) mailboxMessage); handle((PayoutTxPublishedMessage) mailboxMessage);
} }
} }
} }
@ -101,7 +101,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
// OpenOffer requests // OpenOffer requests
private void handleRequestIsOfferAvailableMessage(RequestIsOfferAvailableMessage tradeMessage, Peer sender) { private void handle(RequestIsOfferAvailableMessage tradeMessage, Peer sender) {
try { try {
checkTradeId(processModel.getId(), tradeMessage); checkTradeId(processModel.getId(), tradeMessage);
@ -131,7 +131,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
} }
// Trade started. We reserve the offer for that taker. If anything goes wrong we reset the offer as open. // Trade started. We reserve the offer for that taker. If anything goes wrong we reset the offer as open.
private void handleRequestDepositTxInputsMessage(RequestDepositTxInputsMessage tradeMessage, Peer taker) { private void handle(RequestDepositTxInputsMessage tradeMessage, Peer taker) {
checkTradeId(processModel.getId(), tradeMessage); checkTradeId(processModel.getId(), tradeMessage);
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
trade.setTradingPeer(taker); trade.setTradingPeer(taker);
@ -149,7 +149,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
taskRunner.run(); taskRunner.run();
} }
private void handleRequestPublishDepositTxMessage(RequestPublishDepositTxMessage tradeMessage) { private void handle(RequestPublishDepositTxMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade, TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
@ -188,7 +188,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
// Incoming message handling // Incoming message handling
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
private void handlePayoutTxPublishedMessage(PayoutTxPublishedMessage tradeMessage) { private void handle(PayoutTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade, TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
@ -217,16 +217,16 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
if (tradeMessage.tradeId.equals(trade.getId())) { if (tradeMessage.tradeId.equals(trade.getId())) {
if (tradeMessage instanceof RequestIsOfferAvailableMessage) { if (tradeMessage instanceof RequestIsOfferAvailableMessage) {
handleRequestIsOfferAvailableMessage((RequestIsOfferAvailableMessage) tradeMessage, sender); handle((RequestIsOfferAvailableMessage) tradeMessage, sender);
} }
else if (tradeMessage instanceof RequestDepositTxInputsMessage) { else if (tradeMessage instanceof RequestDepositTxInputsMessage) {
handleRequestDepositTxInputsMessage((RequestDepositTxInputsMessage) tradeMessage, sender); handle((RequestDepositTxInputsMessage) tradeMessage, sender);
} }
else if (tradeMessage instanceof RequestPublishDepositTxMessage) { else if (tradeMessage instanceof RequestPublishDepositTxMessage) {
handleRequestPublishDepositTxMessage((RequestPublishDepositTxMessage) tradeMessage); handle((RequestPublishDepositTxMessage) tradeMessage);
} }
else if (tradeMessage instanceof PayoutTxPublishedMessage) { else if (tradeMessage instanceof PayoutTxPublishedMessage) {
handlePayoutTxPublishedMessage((PayoutTxPublishedMessage) tradeMessage); handle((PayoutTxPublishedMessage) tradeMessage);
} }
else { else {
log.error("Incoming tradeMessage not supported. " + tradeMessage); log.error("Incoming tradeMessage not supported. " + tradeMessage);

16
core/src/main/java/io/bitsquare/trade/protocol/trade/SellerAsTakerProtocol.java
View file

@ -86,10 +86,10 @@ public class SellerAsTakerProtocol implements TradeProtocol {
if (processModel.getMailboxMessage() == null) { if (processModel.getMailboxMessage() == null) {
processModel.setMailboxMessage(mailboxMessage); processModel.setMailboxMessage(mailboxMessage);
if (mailboxMessage instanceof FiatTransferStartedMessage) { if (mailboxMessage instanceof FiatTransferStartedMessage) {
handleFiatTransferStartedMessage((FiatTransferStartedMessage) mailboxMessage); handle((FiatTransferStartedMessage) mailboxMessage);
} }
else if (mailboxMessage instanceof DepositTxPublishedMessage) { else if (mailboxMessage instanceof DepositTxPublishedMessage) {
handleDepositTxPublishedMessage((DepositTxPublishedMessage) mailboxMessage); handle((DepositTxPublishedMessage) mailboxMessage);
} }
} }
} }
@ -112,7 +112,7 @@ public class SellerAsTakerProtocol implements TradeProtocol {
// Incoming message handling // Incoming message handling
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
private void handleRequestTakerDepositPaymentMessage(RequestPayDepositMessage tradeMessage) { private void handle(RequestPayDepositMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade, TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
@ -129,7 +129,7 @@ public class SellerAsTakerProtocol implements TradeProtocol {
taskRunner.run(); taskRunner.run();
} }
private void handleDepositTxPublishedMessage(DepositTxPublishedMessage tradeMessage) { private void handle(DepositTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade, TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
@ -143,7 +143,7 @@ public class SellerAsTakerProtocol implements TradeProtocol {
taskRunner.run(); taskRunner.run();
} }
private void handleFiatTransferStartedMessage(FiatTransferStartedMessage tradeMessage) { private void handle(FiatTransferStartedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage); processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade, TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
@ -192,13 +192,13 @@ public class SellerAsTakerProtocol implements TradeProtocol {
if (tradeMessage.tradeId.equals(processModel.getId())) { if (tradeMessage.tradeId.equals(processModel.getId())) {
if (tradeMessage instanceof RequestPayDepositMessage) { if (tradeMessage instanceof RequestPayDepositMessage) {
handleRequestTakerDepositPaymentMessage((RequestPayDepositMessage) tradeMessage); handle((RequestPayDepositMessage) tradeMessage);
} }
else if (tradeMessage instanceof DepositTxPublishedMessage) { else if (tradeMessage instanceof DepositTxPublishedMessage) {
handleDepositTxPublishedMessage((DepositTxPublishedMessage) tradeMessage); handle((DepositTxPublishedMessage) tradeMessage);
} }
else if (tradeMessage instanceof FiatTransferStartedMessage) { else if (tradeMessage instanceof FiatTransferStartedMessage) {
handleFiatTransferStartedMessage((FiatTransferStartedMessage) tradeMessage); handle((FiatTransferStartedMessage) tradeMessage);
} }
else { else {
log.error("Incoming message not supported. " + tradeMessage); log.error("Incoming message not supported. " + tradeMessage);