private boolean hasChange(DataGrid grid, HashMap<Guid, RelationOrder> relationOrders) { if (grid.get_BindingSource() == null || grid.getRowCount() != relationOrders.size()) { return true; } else { int openOrderSummaryColumn = -1; for (int column = 0; column < grid.getColumnModel().getColumnCount(); column++) { if (grid.getColumnModel() .getColumn(column) .getIdentifier() .equals(OutstandingOrderColKey.OpenOrderSummary)) { openOrderSummaryColumn = column; break; } } for (int row = 0; row < grid.getRowCount(); row++) { RelationOrder realtionOrder = (RelationOrder) grid.getObject(row); Guid openOrderId = realtionOrder.get_OpenOrderId(); RelationOrder realtionOrder2 = relationOrders.get(openOrderId); if (realtionOrder2 == null || realtionOrder2.getAvailableCloseLot().compareTo(realtionOrder.getAvailableCloseLot()) != 0 || (openOrderSummaryColumn > -1 && !realtionOrder2 .get_OpenOrderSummary() .equals(grid.getValueAt(row, openOrderSummaryColumn).toString()))) { return true; } } } return false; }
private HashMap<Guid, RelationOrder> getEditOutstandingOrders( BuySellType buySellType, Order mapOrder) { HashMap<Guid, RelationOrder> editOutstandingOrders; if (buySellType == BuySellType.Both) { editOutstandingOrders = this._outstandingOrders; for (Iterator<RelationOrder> iterator = this._outstandingOrders.values().iterator(); iterator.hasNext(); ) { RelationOrder relationOrder = iterator.next(); if (mapOrder != null) { relationOrder.set_IsSelected(true); } } } else { editOutstandingOrders = new HashMap<Guid, RelationOrder>(); for (Iterator<RelationOrder> iterator = this._outstandingOrders.values().iterator(); iterator.hasNext(); ) { RelationOrder relationOrder = iterator.next(); if (mapOrder != null) { relationOrder.set_IsSelected(true); } if (buySellType == BuySellType.Buy && relationOrder.get_IsBuy()) { editOutstandingOrders.put(relationOrder.get_OpenOrderId(), relationOrder); } else if (buySellType == BuySellType.Sell && !relationOrder.get_IsBuy()) { editOutstandingOrders.put(relationOrder.get_OpenOrderId(), relationOrder); } } } return editOutstandingOrders; }
private boolean initializeOutstanding2( DataGrid grid, boolean ascend, boolean caseOn, BuySellType buySellType, BuySellType editOutstandingOrderBuySellType, IOpenCloseRelationSite openCloseRelationSite, Order mapOrder) { Boolean isSpot = openCloseRelationSite.getOrderType() == null ? null : openCloseRelationSite.getOrderType().isSpot(); this.setOutstandingOrders( buySellType, mapOrder, isSpot, openCloseRelationSite.isMakeLimitOrder(), openCloseRelationSite.isDelivery()); HashMap<Guid, RelationOrder> editOutstandingOrders = this.getEditOutstandingOrders(editOutstandingOrderBuySellType, mapOrder); boolean hasChange = this.hasChange(grid, editOutstandingOrders); if (hasChange) { this.unbindOutstanding(); this._outstandingKey = Guid.newGuid().toString(); this._bindingSourceForOutstanding = new tradingConsole.ui.grid.BindingSource(); boolean isMakeOrder2 = this._settingsManager.get_Customer().get_SingleAccountOrderType() == 2 || this._settingsManager.get_Customer().get_MultiAccountsOrderType() == 2; RelationOrder.initialize( isMakeOrder2, grid, this._outstandingKey, editOutstandingOrders.values(), this._bindingSourceForOutstanding, openCloseRelationSite, editOutstandingOrderBuySellType); int column = this._bindingSourceForOutstanding.getColumnByName(OutstandingOrderColKey.IsBuy); if (column != -1) { grid.sortColumn(column, false, ascend); TableColumnChooser.hideColumn(grid, column); } } else { this._outstandingKey = grid.get_BindingSource().get_DataSourceKey(); this._outstandingOrders.clear(); for (int row = 0; row < grid.getRowCount(); row++) { RelationOrder relationOrder = (RelationOrder) (grid.getObject(row)); this._outstandingOrders.put(relationOrder.get_OpenOrderId(), relationOrder); } } return hasChange; }
// 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 HashMap<Guid, RelationOrder> getPlaceRelation() { HashMap<Guid, RelationOrder> placeRelation = null; HashMap<Guid, RelationOrder> outstandingOrders = this.getOutstandingOrders(); for (RelationOrder relationOrder : outstandingOrders.values()) { if (relationOrder.get_IsSelected() && relationOrder.get_CloseLot().compareTo(BigDecimal.ZERO) > 0) { if (placeRelation == null) placeRelation = new HashMap<Guid, RelationOrder>(); placeRelation.put(relationOrder.get_OpenOrderId(), relationOrder); } } return placeRelation; }
/* 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; }
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; }
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; }
// 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); } } } } } } } }