private void flag() {
Set<Transaction.FraudStatus> permittedFlags = EnumSet.allOf(Transaction.FraudStatus.class);
if (controller.getCurrentUser().getRole() != User.Role.AUDITOR) {
permittedFlags.remove(Transaction.FraudStatus.REVERSED);
}
Transaction.FraudStatus status =
(Transaction.FraudStatus)
JOptionPane.showInputDialog(
this,
"Flag as:",
"Flag",
JOptionPane.QUESTION_MESSAGE,
null,
permittedFlags.toArray(),
Transaction.FraudStatus.NOT_FLAGGED);
if (status == null) {
return;
}
try {
Transaction transaction = account.getHistory().get(historyTable.getSelectedRow());
transaction.setFraudStatus(status, account);
update();
} catch (InvalidInputException iix) {
controller.handleException(this, iix);
} catch (InsufficientFundsException ifx) {
controller.handleException(this, ifx);
}
}
private HashMap<Guid, Transaction> getAccountInstrumentTransactions() {
HashMap<Guid, Transaction> transactions = null;
HashMap<Guid, Transaction> accountTransactions = this._account.get_Transactions();
HashMap<Guid, Transaction> instrumentTransactions = this._instrument.get_Transactions();
if (accountTransactions == null || instrumentTransactions == null) {
return transactions;
}
transactions = new HashMap<Guid, Transaction>();
for (Iterator<Transaction> iterator = accountTransactions.values().iterator();
iterator.hasNext(); ) {
Transaction accountTransaction = iterator.next();
Guid accountTransactionId = accountTransaction.get_Id();
if (instrumentTransactions.containsKey(accountTransactionId)) {
transactions.put(accountTransactionId, accountTransaction);
}
}
return transactions;
}
// for Instrument code with "#"
// for IsBuy = true:
// SumBuy = all confirmed order.Buy.LotBalance + all unconfirmed order.Buy.Lot
// SumSell = all confirmed order.Sell.LotBalance
// for IsBuy = false:
// SumSell = all confirmed order.Sell.LotBalance + all unconfirmed order.Sell.Lot
// SumBuy = all confirmed order.Buy.LotBalance
public GetSumLotBSForOpenOrderWithFlagResult getSumLotBSForOpenOrderWithFlag(boolean isBuy) {
BigDecimal[] sumLot = new BigDecimal[] {BigDecimal.ZERO, BigDecimal.ZERO};
boolean isExistsUnconfirmedOrder = false;
HashMap<Guid, Transaction> accountInstrumentTransactions =
this.getAccountInstrumentTransactions();
for (Iterator<Transaction> iterator = accountInstrumentTransactions.values().iterator();
iterator.hasNext(); ) {
Transaction transaction = iterator.next();
if (transaction.get_Phase() == Phase.Executed
|| transaction.get_Phase() == Phase.Placing
|| transaction.get_Phase() == Phase.Placed) {
for (Iterator<Order> iterator2 = transaction.get_Orders().values().iterator();
iterator2.hasNext(); ) {
Order order = iterator2.next();
if (order.get_LotBalance().compareTo(BigDecimal.ZERO) > 0) {
if (isBuy) {
if (order.get_IsBuy()) {
if (transaction.get_Phase() == Phase.Executed) {
sumLot[0] = sumLot[0].add(order.get_LotBalance());
} else {
sumLot[0] = sumLot[0].add(order.get_Lot());
isExistsUnconfirmedOrder = true;
}
} else {
if (transaction.get_Phase() == Phase.Executed) {
sumLot[1] = sumLot[1].add(order.get_LotBalance());
}
}
} else {
if (order.get_IsBuy()) {
if (transaction.get_Phase() == Phase.Executed) {
sumLot[0] = sumLot[0].add(order.get_LotBalance());
}
} else {
if (transaction.get_Phase() == Phase.Executed) {
sumLot[1] = sumLot[1].add(order.get_LotBalance());
} else {
sumLot[1] = sumLot[1].add(order.get_Lot());
isExistsUnconfirmedOrder = true;
}
}
}
}
}
}
}
return new GetSumLotBSForOpenOrderWithFlagResult(
sumLot[0], sumLot[1], isExistsUnconfirmedOrder);
}
public BigDecimal[] getSumLotBSForOpenOrder() {
BigDecimal[] sumLot = new BigDecimal[] {BigDecimal.ZERO, BigDecimal.ZERO};
HashMap<Guid, Transaction> accountInstrumentTransactions =
this.getAccountInstrumentTransactions();
for (Iterator<Transaction> iterator = accountInstrumentTransactions.values().iterator();
iterator.hasNext(); ) {
Transaction transaction = iterator.next();
if (transaction.get_Phase() == Phase.Executed) {
for (Iterator<Order> iterator2 = transaction.get_Orders().values().iterator();
iterator2.hasNext(); ) {
Order order = iterator2.next();
if (order.get_LotBalance().compareTo(BigDecimal.ZERO) > 0) {
if (order.get_IsBuy()) {
sumLot[0] = sumLot[0].add(order.get_LotBalance());
} else {
sumLot[1] = sumLot[1].add(order.get_LotBalance());
}
}
}
}
}
return sumLot;
}
/*
Remarks
sum (SellLotBalance) = all confirmed order.Sell.LotBalance
+ unconfirmed order (stop).Sell.Lot
+ iif("MOC/MOO allow New" = False,
unconfirmed order (MOO/MOC).Sell.Lot,
0)
sum (BuyLotBalance) = all confirmed order.Buy.LotBalance
+ unconfirmed order (stop).Buy.Lot
+ iif("MOC/MOO allow New" = False,
unconfirmed order (MOO/MOC).Buy.Lot,
0)
*/
public BigDecimal[] getSumLotBSForMakeStopOrder() {
BigDecimal[] sumLot = new BigDecimal[] {BigDecimal.ZERO, BigDecimal.ZERO};
TradePolicyDetail tradePolicyDetail = this.getTradePolicyDetail();
HashMap<Guid, Transaction> accountInstrumentTransactions =
this.getAccountInstrumentTransactions();
for (Iterator<Transaction> iterator = accountInstrumentTransactions.values().iterator();
iterator.hasNext(); ) {
Transaction transaction = iterator.next();
if (transaction.get_Phase() == Phase.Executed) {
for (Iterator<Order> iterator2 = transaction.get_Orders().values().iterator();
iterator2.hasNext(); ) {
Order order = iterator2.next();
if (order.get_LotBalance().compareTo(BigDecimal.ZERO) > 0) {
if (order.get_IsBuy()) {
sumLot[0] = sumLot[0].add(order.get_LotBalance());
} else {
sumLot[1] = sumLot[1].add(order.get_LotBalance());
}
}
}
} else if (transaction.get_Phase() == Phase.Placing
|| transaction.get_Phase() == Phase.Placed) {
for (Iterator<Order> iterator2 = transaction.get_Orders().values().iterator();
iterator2.hasNext(); ) {
Order order = iterator2.next();
if (order.get_TradeOption() == TradeOption.Stop
|| (!tradePolicyDetail.get_IsAcceptNewMOOMOC()
&& (transaction.get_OrderType() == OrderType.MarketOnOpen
|| transaction.get_OrderType() == OrderType.MarketOnClose))) {
if (order.get_IsBuy()) {
sumLot[0] = sumLot[0].add(order.get_Lot());
} else {
sumLot[1] = sumLot[1].add(order.get_Lot());
}
}
}
}
}
return sumLot;
}
// exclude make Liquidation order and make Limit,MOO,MOC,MKT,OCO for mapOrder.....
private void setOutstandingOrders(
BuySellType buySellType, Boolean isSpot, Boolean isMakeLimitOrder, boolean isDelivery) {
/*if (this._outstandingOrders.size() > 0 || this._account.get_Type() == AccountType.Agent)
{
Iterator<RelationOrder> relationOrders = this._outstandingOrders.values().iterator();
while(relationOrders.hasNext())
{
relationOrders.next().set_IsMakeLimitOrder(isMakeLimitOrder);
}
return;
}*/
this._outstandingOrders.clear();
HashMap<Guid, Transaction> accountInstrumentTransactions =
this.getAccountInstrumentTransactions();
for (Iterator<Transaction> iterator = accountInstrumentTransactions.values().iterator();
iterator.hasNext(); ) {
Transaction transaction = iterator.next();
if (transaction.get_Phase().equals(Phase.Executed)) {
for (Iterator<Order> iterator2 = transaction.get_Orders().values().iterator();
iterator2.hasNext(); ) {
Order order = iterator2.next();
if (order.get_Phase() != Phase.Executed) continue;
if (order.get_Transaction().get_Account().get_Type() == AccountType.Agent
|| order.get_Transaction().get_Account().get_Type() == AccountType.Transit) continue;
BigDecimal availableLotBanlance = BigDecimal.ZERO;
if (isDelivery) {
if (order.canDelivery()) {
availableLotBanlance = order.getAvailableDeliveryLot();
if (availableLotBanlance.compareTo(BigDecimal.ZERO) > 0) {
Guid orderId = order.get_Id();
RelationOrder outstandingOrder =
new RelationOrder(
this._tradingConsole, this._settingsManager, order, false, null, true);
this._outstandingOrders.put(orderId, outstandingOrder);
}
}
} else {
if (order.canClose()) {
availableLotBanlance = order.get_LotBalance();
if (isSpot != null)
availableLotBanlance = order.getAvailableLotBanlance(isSpot, isMakeLimitOrder);
if (availableLotBanlance.compareTo(BigDecimal.ZERO) > 0) {
Guid orderId = order.get_Id();
RelationOrder outstandingOrder =
new RelationOrder(this._tradingConsole, this._settingsManager, order);
outstandingOrder.set_IsMakeLimitOrder(isMakeLimitOrder);
if (buySellType.equals(BuySellType.Both)) {
this._outstandingOrders.put(orderId, outstandingOrder);
} else if (order.get_IsBuy() && (buySellType.equals(BuySellType.Buy))) {
this._outstandingOrders.put(orderId, outstandingOrder);
} else if (!order.get_IsBuy() && (buySellType.equals(BuySellType.Sell))) {
this._outstandingOrders.put(orderId, outstandingOrder);
}
}
}
}
}
}
}
}
public void update() {
infoPanel.update();
Object[][] history = new Object[account.getHistory().size()][5];
int i = 0;
for (Transaction t : account.getHistory()) {
history[i][0] = t.getType();
BigDecimal amount;
BigDecimal balance;
if (account.getType().isLoan()) {
amount = (t.getType().isPositive() ? t.getAmount().negate() : t.getAmount());
balance = t.getBalance().negate();
} else {
amount = (t.getType().isPositive() ? t.getAmount() : t.getAmount().negate());
balance = t.getBalance();
}
history[i][1] = FORMATTER.valueToString(amount);
history[i][2] = FORMATTER.valueToString(balance);
history[i][3] = t.getTimestamp();
history[i][4] = t.getFraudStatus();
i++;
}
historyTable.setModel(
new javax.swing.table.DefaultTableModel(
history, new String[] {"Type", "Amount", "Balance", "Month", "Flag"}) {
@Override
public boolean isCellEditable(int rowIndex, int columnIndex) {
return false;
}
});
historyTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
historyTable.revalidate();
}