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);
}
}
}
}
}
}
}
}
