Beispiel #1
0
  @Override
  public void modifyTransaction(final Transaction tran) {
    if (!(tran instanceof InvestmentTransaction)) {
      throw new IllegalArgumentException("bad tranType");
    }
    clearForm();

    datePanel.setDate(tran.getDate());

    List<TransactionEntry> entries = tran.getTransactionEntries();

    feePanel.setTransactionEntries(((InvestmentTransaction) tran).getInvestmentFeeEntries());

    gainsPanel.setTransactionEntries(((InvestmentTransaction) tran).getInvestmentGainLossEntries());

    for (TransactionEntry e : entries) {
      if (e instanceof TransactionEntrySellX) {
        AbstractInvestmentTransactionEntry entry = (AbstractInvestmentTransactionEntry) e;

        memoField.setText(e.getMemo());
        priceField.setDecimal(entry.getPrice());
        quantityField.setDecimal(entry.getQuantity());
        securityCombo.setSelectedNode(entry.getSecurityNode());

        accountExchangePanel.setSelectedAccount(entry.getDebitAccount());
        accountExchangePanel.setExchangedAmount(entry.getDebitAmount().abs());
      }
    }

    updateTotalField();

    modTrans = tran;

    reconciledButton.setSelected(tran.getReconciled(getAccount()) == ReconciledState.RECONCILED);
  }
  @FXML
  @Override
  public void handleEnterAction() {
    if (validateForm()) {
      if (modTrans == null) { // new transaction
        Transaction newTrans = buildTransaction();

        ReconcileManager.reconcileTransaction(
            accountProperty.get(), newTrans, getReconciledState());

        newTrans = attachmentPane.buildTransaction(newTrans); // chain the transaction build

        final Engine engine = EngineFactory.getEngine(EngineFactory.DEFAULT);

        if (engine != null) {
          engine.addTransaction(newTrans);
        }
      } else {
        Transaction newTrans = buildTransaction();

        newTrans.setDateEntered(modTrans.getDateEntered());

        // restore the reconciled state of the previous old transaction
        for (final Account a : modTrans.getAccounts()) {
          if (!a.equals(accountProperty.get())) {
            ReconcileManager.reconcileTransaction(a, newTrans, modTrans.getReconciled(a));
          }
        }

        /*
         * Reconcile the modified transaction for this account.
         * This must be performed last to ensure consistent results per the ReconcileManager rules
         */
        ReconcileManager.reconcileTransaction(
            accountProperty.get(), newTrans, getReconciledState());

        newTrans = attachmentPane.buildTransaction(newTrans); // chain the transaction build

        final Engine engine = EngineFactory.getEngine(EngineFactory.DEFAULT);

        if (engine != null && engine.removeTransaction(modTrans)) {
          engine.addTransaction(newTrans);
        }
      }
      clearForm();

      if (payeeTextField != null) {
        payeeTextField.requestFocus();
      } else {
        memoTextField.requestFocus();
      }
    }
  }
  private void newTransaction(final Transaction t) {
    clearForm();

    amountField.setDecimal(t.getAmount(accountProperty().get()));

    memoTextField.setText(t.getMemo());
    payeeTextField.setText(t.getPayee());
    numberComboBox.setValue(t.getNumber());

    datePicker.setValue(t.getLocalDate());
    setReconciledState(t.getReconciled(accountProperty().get()));
  }
  @Override
  public void modifyTransaction(@NotNull final Transaction transaction) {
    if (!(transaction.getTransactionType() == TransactionType.REMOVESHARE
        || transaction.getTransactionType() == TransactionType.ADDSHARE)) {
      throw new IllegalArgumentException(
          resources.getString("Message.Error.InvalidTransactionType"));
    }

    clearForm();

    datePicker.setValue(transaction.getLocalDate());
    memoTextField.setText(transaction.getMemo());
    numberComboBox.setValue(transaction.getNumber());
    priceField.setDecimal(((InvestmentTransaction) transaction).getPrice());
    quantityField.setDecimal(((InvestmentTransaction) transaction).getQuantity());
    securityComboBox.setSecurityNode(((InvestmentTransaction) transaction).getSecurityNode());

    setReconciledState(transaction.getReconciled(accountProperty().get()));

    modTrans = transaction;
    modTrans = attachmentPane.modifyTransaction(modTrans);
  }
  @Override
  public void modifyTransaction(Transaction tran) {

    assert tran instanceof InvestmentTransaction;

    assert tran.getTransactionType() == TransactionType.ADDSHARE
        || tran.getTransactionType() == TransactionType.REMOVESHARE;

    InvestmentTransaction _tran = (InvestmentTransaction) tran;

    clearForm();

    modTrans = tran;

    datePanel.setDate(tran.getLocalDate());
    memoField.setText(tran.getMemo());
    priceField.setDecimal(_tran.getPrice());
    quantityField.setDecimal(_tran.getQuantity());
    securityCombo.setSelectedNode(_tran.getSecurityNode());

    setReconciledState(tran.getReconciled(getAccount()));

    updateTotalField();
  }