private void closeOpenOrder(OpenOrder openOrder, double commissionAmount) { openOrdersById.remove(openOrder.getOrderId()); if (Double.isNaN(commissionAmount) || commissionAmount <= 0.0) { commissionAmount = commission.calculate(openOrder.getQuantityFilled(), openOrder.getAvgFillPrice()); } openOrder.setCommission(commissionAmount); logger.info("{} {}", openOrder.isFilled() ? "Filled" : "Partially filled", openOrder); Position position = portfolio.getPosition(openOrder.getSymbol()); double[] values = position.update( openOrder.getFillDate(), openOrder.getQuantityFilled(), openOrder.getAvgFillPrice(), openOrder.getCommission()); logTrade(openOrder, position.getQuantity(), values[0], values[1], values[2]); for (OrderListener listener : orderListeners) { try { listener.onOrderFilled(openOrder, position); } catch (Throwable t) { logger.error(t.getMessage(), t); } } }
@Override public void openOrder(int orderId, Contract contract, Order order, OrderState orderState) { try { if (logger.isDebugEnabled()) logger.debug( "openOrder: {} {} {} {}", new Object[] { orderId, Util.toString(contract), Util.toString(order), Util.toString(orderState) }); OpenOrder openOrder = openOrdersById.get(orderId); if (openOrder != null) { if ((openOrder.isFilled() || (!openOrder.isOpen() && openOrder.getQuantityFilled() > 0)) && orderState.m_commission != Double.MAX_VALUE) { closeOpenOrder(openOrder, orderState.m_commission); } } else { if ("PendingSubmit".equals(orderState.m_status) || "PreSubmitted".equals(orderState.m_status) || "Submitted".equals(orderState.m_status)) { openOrder = toOpenOrder(contract, order); openOrdersById.put(orderId, openOrder); logger.info("Added {}", openOrder); } } } catch (Throwable t) { logger.error(t.getMessage(), t); } }
@Override public void execDetails(int reqId, Contract contract, Execution execution) { try { if (logger.isDebugEnabled()) logger.debug( "execDetails: {} {} {}", new Object[] {reqId, Util.toString(contract), Util.toString(execution)}); OpenOrder openOrder = openOrdersById.get(execution.m_orderId); DateTime dt = DateTimeFormat.forPattern("yyyyMMdd HH:mm:ss").parseDateTime(execution.m_time); if (openOrder != null) { int quantityChange = openOrder.isBuy() ? execution.m_shares : -execution.m_shares; openOrder.update(quantityChange, execution.m_price, dt); logExecution(openOrder, quantityChange); } else { logger.info( "Execution does not match any open order {} {}", Util.toString(contract), Util.toString(execution)); } } catch (Throwable t) { // Do not allow exceptions come back to the socket -- it will cause // disconnects logger.error(t.getMessage(), t); } }
@Override public void orderStatus( int orderId, String status, int filled, int remaining, double avgFillPrice, int permId, int parentId, double lastFillPrice, int clientId, String whyHeld) { try { if (logger.isDebugEnabled()) logger.debug( "orderStatus: {} {} {} {} {} {} {} {} {} {}", new Object[] { orderId, status, filled, remaining, avgFillPrice, permId, parentId, lastFillPrice, clientId, whyHeld }); if ("Cancelled".equals(status)) { OpenOrder openOrder = openOrdersById.remove(orderId); if (openOrder != null) { openOrder.setCancelled(); logger.info("Cancelled {}", openOrder); for (OrderListener listener : orderListeners) { try { listener.onOrderCancelled(openOrder); } catch (Throwable t) { logger.error(t.getMessage(), t); } } if ((openOrder.isFilled() || (!openOrder.isOpen() && openOrder.getQuantityFilled() > 0))) { closeOpenOrder(openOrder, 0); } } else { logger.warn("Cancelled order {}, no matching order found!", orderId); } } } catch (Throwable t) { // Do not allow exceptions come back to the socket -- it will cause // disconnects logger.error(t.getMessage(), t); } }
@Override public List<OpenOrder> getOpenOrders(Symbol symbol, OrderType orderType) { List<OpenOrder> openOrders = new ArrayList<OpenOrder>(openOrdersById.size()); for (OpenOrder o : openOrdersById.values()) { if ((symbol == null || symbol.equals(o.getSymbol())) && (orderType == null || orderType.equals(o.getType()))) { openOrders.add(o); } } return openOrders; }
@Override public OpenOrder getOpenOrder(Symbol symbol, OrderType orderType) { if (symbol == null) { throw new IllegalArgumentException("Symbol cannot be null"); } if (orderType == null) { throw new IllegalArgumentException("OrderType cannot be null"); } for (OpenOrder o : openOrdersById.values()) { if (symbol.equals(o.getSymbol()) && orderType.equals(o.getType())) { return o; } } return null; }
@Override public void error(int reqId, int errorCode, String errorMsg) { try { Object req = openOrdersById.get(reqId); if (req == null) { super.error(reqId, errorCode, errorMsg); return; } OpenOrder openOrder = (OpenOrder) req; String message = errorCode + ": " + errorMsg; lastMessage = message; switch (errorCode) { case 161: // 161: Cancel attempted when order is not in a cancellable // state logger.warn("Received error for {}: {}", openOrder, message); break; case 202: // 202: Order Cancelled break; case 110: // 110: price does not conform to the minimum price variation // for this // contract default: openOrder.setFailed(); openOrdersById.remove(reqId); logger.warn("Received error for {}: {}", openOrder, message); } } catch (Throwable t) { // Do not allow exceptions come back to the socket -- it will cause // disconnects logger.error(t.getMessage(), t); } }
protected void logTrade( OpenOrder openOrder, int position, double costBasis, double realized, double unrealized) { Object[] params = new Object[] { openOrder.getFillDate(), "TRADE", openOrder.getAction(), openOrder.getType(), openOrder.getQuantityFilled(), openOrder.getSymbol(), openOrder.getSymbol().getCurrency(), openOrder.getAvgFillPrice(), position, Util.round(costBasis, 4), Util.round(realized, 4), Util.round(unrealized, 4), Util.round(openOrder.getCommission(), 4), openOrder.getReference() != null ? openOrder.getReference() : "", accountCode }; blotter.info( MarkerFactory.getMarker("TRADE"), "{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}", params); }
protected void logExecution(OpenOrder openOrder, int quantity) { Object[] params = new Object[] { openOrder.getFillDate(), "EXEC", openOrder.getAction(), openOrder.getType(), quantity, openOrder.getSymbol(), openOrder.getSymbol().getCurrency(), openOrder.getLastFillPrice(), "", "", "", "", "", openOrder.getReference() != null ? openOrder.getReference() : "", accountCode }; blotter.info( MarkerFactory.getMarker("EXECUTION"), "{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}", params); }
@Override public synchronized void cancelOrder(OpenOrder openOrder) { checkConnected(); socket.cancelOrder(openOrder.getOrderId()); }
@Override public synchronized OpenOrder placeOrder( Symbol symbol, OrderType type, int quantity, double price, double stopPercent, String reference) { if (quantity == 0) { throw new IllegalArgumentException(String.format("Invalid quantity %s", quantity)); } if ((OrderType.LIMIT.equals(type) || OrderType.STOP_LIMIT.equals(type) || OrderType.TRAIL_LIMIT.equals(type)) && price <= 0) { throw new IllegalArgumentException(String.format("Invalid limit order price %s", price)); } if ((OrderType.STOP_MARKET.equals(type) || OrderType.STOP_LIMIT.equals(type) || OrderType.TRAIL_MARKET.equals(type) || OrderType.TRAIL_LIMIT.equals(type)) && stopPercent <= 0) { throw new IllegalArgumentException( String.format("Invalid stop order with stop percent %s", stopPercent)); } checkConnected(); OpenOrder openOrder = getOpenOrder(symbol, type); if (openOrder != null && !openOrder.isFilled() && !openOrder.isCancelled()) { throw new IllegalStateException( "OpenOrder for same strategy, symbol and type already exists: " + openOrder); } DateTime now = new DateTime(); double stopPrice = -1; double trailingStopOffset = -1; if (OrderType.STOP_MARKET.equals(type) || OrderType.STOP_LIMIT.equals(type) || OrderType.TRAIL_MARKET.equals(type) || OrderType.TRAIL_LIMIT.equals(type)) { Tick t = getLastTick(symbol); if (t == null) { t = getLastTick(symbol, now); if (t == null) { throw new IllegalStateException( String.format("Cannot set stop without tick data for symbol %s", symbol)); } } trailingStopOffset = Util.round(t.getMidPrice() * stopPercent, 10.0); if (quantity < 0) { stopPrice = t.getMidPrice() - trailingStopOffset; } else { stopPrice = t.getMidPrice() + trailingStopOffset; } stopPrice = Util.round(stopPrice, 2.0); } int orderId = nextValidOrderId.getAndIncrement(); openOrder = new OpenOrder( orderId, symbol, type, quantity, price, stopPrice, trailingStopOffset, new DateTime(), reference); openOrdersById.put(orderId, openOrder); Contract contract = makeContract(symbol); Order order = makeOrder(openOrder); logger.info("Placing order {}", openOrder); socket.placeOrder(orderId, contract, order); for (OrderListener listener : orderListeners) { try { listener.onOrderPlaced(openOrder); } catch (Throwable t) { logger.error(t.getMessage(), t); } } return openOrder; }
protected Order makeOrder(OpenOrder openOrder) { Order order = new Order(); order.m_orderRef = openOrder.getReference() != null ? openOrder.getReference() : ""; order.m_overridePercentageConstraints = true; order.m_totalQuantity = Math.abs(openOrder.getQuantity()); if (openOrder.isBuy()) { order.m_action = "BUY"; } else if (openOrder.isSell()) { order.m_action = "SELL"; } if (openOrder.isMarket()) { order.m_orderType = "MKT"; } else if (openOrder.isLimit()) { order.m_orderType = "LMT"; order.m_lmtPrice = openOrder.getPrice(); } else if (openOrder.isStopMarket()) { order.m_orderType = "STP"; order.m_triggerMethod = 8; // midpoint order.m_auxPrice = openOrder.getStopPrice(); } else if (openOrder.isStopLimit()) { order.m_orderType = "STPLMT"; order.m_triggerMethod = 8; // midpoint order.m_lmtPrice = openOrder.getPrice(); order.m_auxPrice = openOrder.getStopPrice(); } else if (openOrder.isTrailMarket()) { order.m_orderType = "TRAIL"; order.m_triggerMethod = 8; // midpoint order.m_auxPrice = openOrder.getTrailStopOffset(); } else if (openOrder.isTrailLimit()) { order.m_orderType = "TRAILLMT"; order.m_triggerMethod = 8; // midpoint order.m_lmtPrice = openOrder.getPrice(); order.m_trailStopPrice = openOrder.getStopPrice(); order.m_auxPrice = openOrder.getTrailStopOffset(); } return order; }