Exemplo n.º 1
0
 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;
 }
Exemplo n.º 2
0
 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;
 }
Exemplo n.º 3
0
  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;
  }
Exemplo n.º 4
0
  // 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);
  }
Exemplo n.º 5
0
  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;
  }
Exemplo n.º 6
0
  /*
  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;
  }
Exemplo n.º 7
0
 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;
 }
Exemplo n.º 8
0
 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;
 }
Exemplo n.º 9
0
  // 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);
                }
              }
            }
          }
        }
      }
    }
  }