Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-04-20 23:56:30 -04:00
Code Issues Packages Projects Releases 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
Show Stats 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.LoggerFactory;
public class TakerAsBuyerSubView extends TradeSubView {
private static final Logger log = LoggerFactory.getLogger(TakerAsBuyerSubView.class);
public class BuyerSubView extends TradeSubView {
private static final Logger log = LoggerFactory.getLogger(BuyerSubView.class);
private TradeWizardItem waitTxInBlockchain;
private TradeWizardItem startFiat;
@ -42,7 +41,7 @@ public class TakerAsBuyerSubView extends TradeSubView {
// Constructor, Initialisation
///////////////////////////////////////////////////////////////////////////////////////////
public TakerAsBuyerSubView(PendingTradesViewModel model) {
public BuyerSubView(PendingTradesViewModel model) {
super(model);
}
@ -83,7 +82,7 @@ public class TakerAsBuyerSubView extends TradeSubView {
switch (viewState) {
case EMPTY:
break;
case TAKER_BUYER_WAIT_TX_CONF:
case BUYER_WAIT_TX_CONF:
showItem(waitTxInBlockchain);
((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" +
" recommend to wait up to 6 confirmations.");
break;
case TAKER_BUYER_START_PAYMENT:
case BUYER_START_PAYMENT:
waitTxInBlockchain.done();
showItem(startFiat);
break;
case TAKER_BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED:
case BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED:
waitTxInBlockchain.done();
startFiat.done();
showItem(waitFiatReceived);
@ -108,7 +107,7 @@ public class TakerAsBuyerSubView extends TradeSubView {
"the Bitcoin sellers payment account, the payout transaction will be published.",
model.getCurrencyCode()));
break;
case TAKER_BUYER_COMPLETED:
case BUYER_COMPLETED:
waitTxInBlockchain.done();
startFiat.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.gui.components.Popups;
import io.bitsquare.offer.Offer;
import io.bitsquare.trade.BuyerAsOffererTrade;
import io.bitsquare.trade.BuyerAsTakerTrade;
import io.bitsquare.trade.BuyerTrade;
import io.bitsquare.trade.Contract;
import io.bitsquare.trade.SellerAsOffererTrade;
import io.bitsquare.trade.SellerAsTakerTrade;
import io.bitsquare.trade.SellerTrade;
import io.bitsquare.trade.Trade;
import io.bitsquare.trade.TradeManager;
@ -71,10 +67,8 @@ class PendingTradesDataModel implements Activatable, DataModel {
final StringProperty txId = new SimpleStringProperty();
final IntegerProperty selectedIndex = new SimpleIntegerProperty(-1);
final ObjectProperty<TradeState.ProcessState> takerAsSellerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<TradeState.ProcessState> offererAsBuyerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<TradeState.ProcessState> takerAsBuyerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<TradeState.ProcessState> offererAsSellerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<TradeState.ProcessState> sellerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<TradeState.ProcessState> buyerProcessState = new SimpleObjectProperty<>();
final ObjectProperty<Trade> currentTrade = new SimpleObjectProperty<>();
@ -139,15 +133,10 @@ class PendingTradesDataModel implements Activatable, DataModel {
Trade trade = item.getTrade();
isOfferer = trade.getOffer().getP2pSigPubKey().equals(user.getP2pSigPubKey());
// TODO merge states
if (trade instanceof SellerAsTakerTrade)
takerAsSellerProcessState.bind(trade.processStateProperty());
else if (trade instanceof BuyerAsOffererTrade)
offererAsBuyerProcessState.bind(trade.processStateProperty());
else if (trade instanceof BuyerAsTakerTrade)
takerAsBuyerProcessState.bind(trade.processStateProperty());
else if (trade instanceof SellerAsOffererTrade)
offererAsSellerProcessState.bind(trade.processStateProperty());
if (trade instanceof SellerTrade)
sellerProcessState.bind(trade.processStateProperty());
else if (trade instanceof BuyerTrade)
buyerProcessState.bind(trade.processStateProperty());
if (trade.getDepositTx() != null)
txId.set(trade.getDepositTx().getHashAsString());
@ -253,10 +242,8 @@ class PendingTradesDataModel implements Activatable, DataModel {
}
private void unbindStates() {
takerAsSellerProcessState.unbind();
takerAsBuyerProcessState.unbind();
offererAsBuyerProcessState.unbind();
offererAsSellerProcessState.unbind();
sellerProcessState.unbind();
buyerProcessState.unbind();
}
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.isBuyOffer())
currentSubView = new OffererAsBuyerSubView(model);
currentSubView = new BuyerSubView(model);
else
currentSubView = new OffererAsSellerSubView(model);
currentSubView = new SellerSubView(model);
}
else {
if (model.isBuyOffer())
currentSubView = new TakerAsSellerSubView(model);
currentSubView = new SellerSubView(model);
else
currentSubView = new TakerAsBuyerSubView(model);
currentSubView = new BuyerSubView(model);
}
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 {
EMPTY,
TAKER_SELLER_WAIT_TX_CONF,
TAKER_SELLER_WAIT_PAYMENT_STARTED,
TAKER_SELLER_CONFIRM_RECEIVE_PAYMENT,
TAKER_SELLER_COMPLETED,
SELLER_WAIT_TX_CONF,
SELLER_WAIT_PAYMENT_STARTED,
SELLER_CONFIRM_RECEIVE_PAYMENT,
SELLER_COMPLETED,
OFFERER_BUYER_WAIT_TX_CONF,
OFFERER_BUYER_START_PAYMENT,
OFFERER_BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED,
OFFERER_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,
BUYER_WAIT_TX_CONF,
BUYER_START_PAYMENT,
BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED,
BUYER_COMPLETED,
MESSAGE_SENDING_FAILED,
EXCEPTION
@ -83,10 +73,8 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
private Navigation navigation;
private final BSFormatter formatter;
private final InvalidationListener takerAsSellerStateListener;
private final InvalidationListener offererAsBuyerStateListener;
private final InvalidationListener takerAsBuyerStateListener;
private final InvalidationListener offererAsSellerStateListener;
private final InvalidationListener sellerStateListener;
private final InvalidationListener buyerStateListener;
private final BtcAddressValidator btcAddressValidator;
@ -105,10 +93,8 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
this.formatter = formatter;
this.btcAddressValidator = btcAddressValidator;
this.takerAsSellerStateListener = (ov) -> updateTakerAsSellerState();
this.offererAsBuyerStateListener = (ov) -> updateOffererAsBuyerState();
this.takerAsBuyerStateListener = (ov) -> updateTakerAsBuyerState();
this.offererAsSellerStateListener = (ov) -> updateOffererAsSellerState();
this.sellerStateListener = (ov) -> updateSellerState();
this.buyerStateListener = (ov) -> updateBuyerState();
}
@Override
@ -116,15 +102,11 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
txId.bind(dataModel.txId);
selectedIndex.bind(dataModel.selectedIndex);
dataModel.takerAsSellerProcessState.addListener(takerAsSellerStateListener);
dataModel.offererAsBuyerProcessState.addListener(offererAsBuyerStateListener);
dataModel.takerAsBuyerProcessState.addListener(takerAsBuyerStateListener);
dataModel.offererAsSellerProcessState.addListener(offererAsSellerStateListener);
dataModel.sellerProcessState.addListener(sellerStateListener);
dataModel.buyerProcessState.addListener(buyerStateListener);
updateTakerAsSellerState();
updateOffererAsBuyerState();
updateTakerAsBuyerState();
updateOffererAsSellerState();
updateSellerState();
updateBuyerState();
}
@Override
@ -132,10 +114,8 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
txId.unbind();
selectedIndex.unbind();
dataModel.takerAsSellerProcessState.removeListener(takerAsSellerStateListener);
dataModel.offererAsBuyerProcessState.removeListener(offererAsBuyerStateListener);
dataModel.takerAsBuyerProcessState.removeListener(takerAsBuyerStateListener);
dataModel.offererAsSellerProcessState.removeListener(offererAsSellerStateListener);
dataModel.sellerProcessState.removeListener(sellerStateListener);
dataModel.buyerProcessState.removeListener(buyerStateListener);
}
@ -273,163 +253,168 @@ public class PendingTradesViewModel extends ActivatableWithDataModel<PendingTrad
return dataModel.getErrorMessage();
}
private void updateTakerAsSellerState() {
TakerTradeState.ProcessState processState = (TakerTradeState.ProcessState) dataModel.takerAsSellerProcessState.get();
log.debug("updateTakerAsSellerState " + 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;
private void updateSellerState() {
if (dataModel.sellerProcessState.get() instanceof TakerTradeState.ProcessState) {
TakerTradeState.ProcessState processState = (TakerTradeState.ProcessState) dataModel.sellerProcessState.get();
log.debug("updateSellerState (TakerTradeState) " + 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_SELLER_WAIT_TX_CONF);
break;
case DEPOSIT_CONFIRMED:
viewState.set(ViewState.TAKER_SELLER_WAIT_PAYMENT_STARTED);
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.TAKER_SELLER_CONFIRM_RECEIVE_PAYMENT);
break;
case FIAT_PAYMENT_STARTED:
viewState.set(ViewState.SELLER_CONFIRM_RECEIVE_PAYMENT);
break;
case FIAT_PAYMENT_RECEIVED:
case PAYOUT_PUBLISHED:
viewState.set(ViewState.TAKER_SELLER_COMPLETED);
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;
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;
default:
log.warn("unhandled processState " + processState);
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() {
OffererTradeState.ProcessState processState = (OffererTradeState.ProcessState) dataModel.offererAsBuyerProcessState.get();
log.debug("updateOffererAsBuyerState " + processState);
if (processState != null) {
switch (processState) {
case UNDEFINED:
break;
case DEPOSIT_PUBLISHED:
viewState.set(ViewState.OFFERER_BUYER_WAIT_TX_CONF);
break;
case DEPOSIT_CONFIRMED:
viewState.set(ViewState.OFFERER_BUYER_START_PAYMENT);
break;
private void updateBuyerState() {
if (dataModel.buyerProcessState.get() instanceof TakerTradeState.ProcessState) {
TakerTradeState.ProcessState processState = (TakerTradeState.ProcessState) dataModel.buyerProcessState.get();
log.debug("updateBuyerState (TakerTradeState)" + 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 FIAT_PAYMENT_STARTED:
viewState.set(ViewState.OFFERER_BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED);
break;
case DEPOSIT_PUBLISHED:
viewState.set(ViewState.BUYER_WAIT_TX_CONF);
break;
case DEPOSIT_CONFIRMED:
viewState.set(ViewState.BUYER_START_PAYMENT);
break;
case PAYOUT_PUBLISHED:
viewState.set(ViewState.OFFERER_BUYER_COMPLETED);
break;
case FIAT_PAYMENT_STARTED:
viewState.set(ViewState.BUYER_WAIT_CONFIRM_PAYMENT_RECEIVED);
break;
case MESSAGE_SENDING_FAILED:
viewState.set(ViewState.MESSAGE_SENDING_FAILED);
break;
case EXCEPTION:
viewState.set(ViewState.EXCEPTION);
break;
case FIAT_PAYMENT_RECEIVED:
case PAYOUT_PUBLISHED:
viewState.set(ViewState.BUYER_COMPLETED);
break;
default:
log.warn("unhandled viewState " + processState);
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;
}
}
}
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.LoggerFactory;
public class TakerAsSellerSubView extends TradeSubView {
private static final Logger log = LoggerFactory.getLogger(TakerAsSellerSubView.class);
public class SellerSubView extends TradeSubView {
private static final Logger log = LoggerFactory.getLogger(SellerSubView.class);
private TradeWizardItem waitTxInBlockchain;
private TradeWizardItem waitFiatStarted;
@ -40,7 +40,7 @@ public class TakerAsSellerSubView extends TradeSubView {
// Constructor, Initialisation
///////////////////////////////////////////////////////////////////////////////////////////
public TakerAsSellerSubView(PendingTradesViewModel model) {
public SellerSubView(PendingTradesViewModel model) {
super(model);
}
@ -81,7 +81,7 @@ public class TakerAsSellerSubView extends TradeSubView {
switch (viewState) {
case EMPTY:
break;
case TAKER_SELLER_WAIT_TX_CONF:
case SELLER_WAIT_TX_CONF:
showItem(waitTxInBlockchain);
((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.",
model.getCurrencyCode()));
break;
case TAKER_SELLER_WAIT_PAYMENT_STARTED:
case SELLER_WAIT_PAYMENT_STARTED:
waitTxInBlockchain.done();
showItem(waitFiatStarted);
@ -106,7 +106,7 @@ public class TakerAsSellerSubView extends TradeSubView {
"the {0} payment has been started.",
model.getCurrencyCode()));
break;
case TAKER_SELLER_CONFIRM_RECEIVE_PAYMENT:
case SELLER_CONFIRM_RECEIVE_PAYMENT:
waitTxInBlockchain.done();
waitFiatStarted.done();
showItem(confirmFiatReceived);
@ -121,7 +121,7 @@ public class TakerAsSellerSubView extends TradeSubView {
model.getCurrencyCode()));
break;
case TAKER_SELLER_COMPLETED:
case SELLER_COMPLETED:
waitTxInBlockchain.done();
waitFiatStarted.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) {
processModel.setMailboxMessage(mailboxMessage);
if (mailboxMessage instanceof PayoutTxPublishedMessage) {
handlePayoutTxPublishedMessage((PayoutTxPublishedMessage) mailboxMessage);
handle((PayoutTxPublishedMessage) mailboxMessage);
}
}
}
@ -101,7 +101,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
///////////////////////////////////////////////////////////////////////////////////////////
// OpenOffer requests
private void handleRequestIsOfferAvailableMessage(RequestIsOfferAvailableMessage tradeMessage, Peer sender) {
private void handle(RequestIsOfferAvailableMessage tradeMessage, Peer sender) {
try {
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.
private void handleRequestDepositTxInputsMessage(RequestDepositTxInputsMessage tradeMessage, Peer taker) {
private void handle(RequestDepositTxInputsMessage tradeMessage, Peer taker) {
checkTradeId(processModel.getId(), tradeMessage);
processModel.setTradeMessage(tradeMessage);
trade.setTradingPeer(taker);
@ -149,7 +149,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
taskRunner.run();
}
private void handleRequestPublishDepositTxMessage(RequestPublishDepositTxMessage tradeMessage) {
private void handle(RequestPublishDepositTxMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
@ -188,7 +188,7 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
// Incoming message handling
///////////////////////////////////////////////////////////////////////////////////////////
private void handlePayoutTxPublishedMessage(PayoutTxPublishedMessage tradeMessage) {
private void handle(PayoutTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
@ -217,16 +217,16 @@ public class BuyerAsOffererProtocol implements TradeProtocol {
if (tradeMessage.tradeId.equals(trade.getId())) {
if (tradeMessage instanceof RequestIsOfferAvailableMessage) {
handleRequestIsOfferAvailableMessage((RequestIsOfferAvailableMessage) tradeMessage, sender);
handle((RequestIsOfferAvailableMessage) tradeMessage, sender);
}
else if (tradeMessage instanceof RequestDepositTxInputsMessage) {
handleRequestDepositTxInputsMessage((RequestDepositTxInputsMessage) tradeMessage, sender);
handle((RequestDepositTxInputsMessage) tradeMessage, sender);
}
else if (tradeMessage instanceof RequestPublishDepositTxMessage) {
handleRequestPublishDepositTxMessage((RequestPublishDepositTxMessage) tradeMessage);
handle((RequestPublishDepositTxMessage) tradeMessage);
}
else if (tradeMessage instanceof PayoutTxPublishedMessage) {
handlePayoutTxPublishedMessage((PayoutTxPublishedMessage) tradeMessage);
handle((PayoutTxPublishedMessage) tradeMessage);
}
else {
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) {
processModel.setMailboxMessage(mailboxMessage);
if (mailboxMessage instanceof FiatTransferStartedMessage) {
handleFiatTransferStartedMessage((FiatTransferStartedMessage) mailboxMessage);
handle((FiatTransferStartedMessage) mailboxMessage);
}
else if (mailboxMessage instanceof DepositTxPublishedMessage) {
handleDepositTxPublishedMessage((DepositTxPublishedMessage) mailboxMessage);
handle((DepositTxPublishedMessage) mailboxMessage);
}
}
}
@ -112,7 +112,7 @@ public class SellerAsTakerProtocol implements TradeProtocol {
// Incoming message handling
///////////////////////////////////////////////////////////////////////////////////////////
private void handleRequestTakerDepositPaymentMessage(RequestPayDepositMessage tradeMessage) {
private void handle(RequestPayDepositMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
@ -129,7 +129,7 @@ public class SellerAsTakerProtocol implements TradeProtocol {
taskRunner.run();
}
private void handleDepositTxPublishedMessage(DepositTxPublishedMessage tradeMessage) {
private void handle(DepositTxPublishedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
@ -143,7 +143,7 @@ public class SellerAsTakerProtocol implements TradeProtocol {
taskRunner.run();
}
private void handleFiatTransferStartedMessage(FiatTransferStartedMessage tradeMessage) {
private void handle(FiatTransferStartedMessage tradeMessage) {
processModel.setTradeMessage(tradeMessage);
TaskRunner<Trade> taskRunner = new TaskRunner<>(trade,
@ -192,13 +192,13 @@ public class SellerAsTakerProtocol implements TradeProtocol {
if (tradeMessage.tradeId.equals(processModel.getId())) {
if (tradeMessage instanceof RequestPayDepositMessage) {
handleRequestTakerDepositPaymentMessage((RequestPayDepositMessage) tradeMessage);
handle((RequestPayDepositMessage) tradeMessage);
}
else if (tradeMessage instanceof DepositTxPublishedMessage) {
handleDepositTxPublishedMessage((DepositTxPublishedMessage) tradeMessage);
handle((DepositTxPublishedMessage) tradeMessage);
}
else if (tradeMessage instanceof FiatTransferStartedMessage) {
handleFiatTransferStartedMessage((FiatTransferStartedMessage) tradeMessage);
handle((FiatTransferStartedMessage) tradeMessage);
}
else {
log.error("Incoming message not supported. " + tradeMessage);