private void eh_OrderStatus(object sender, OrderStatusEventArgs e)
{
DisplayedOrder dOrder = mainWin.Orders.FirstOrDefault <DisplayedOrder>(x => x.OrderId == e.OrderId);
if (dOrder == null)
{
mainWin.LogList.Insert(0, new Log()
{
Text = String.Format("Order Id: %d cannot be found", e.OrderId), Time = DateTime.Now
});
}
else
{
// make a copy if every step needs keeping
if (mainWin.UserPreference.KeepTradeSteps)
{
dOrder = dOrder.ShallowCopy();
dOrder.Time = DateTime.Now;
System.Windows.Threading.Dispatcher.FromThread(OrderManager.UIThread).Invoke(() =>
{
mainWin.Orders.Insert(0, dOrder);
});
}
System.Windows.Threading.Dispatcher.FromThread(OrderManager.UIThread).Invoke(() =>
{
dOrder.Status = e.Status;
dOrder.Filled = e.Filled;
dOrder.Remaining = e.Remaining;
dOrder.AvgPrice = e.AvgFillPrice;
});
}
}
public async Task WhenPositionFilledRecordTradeExitAsync()
{
// Arrange
const double FillPrice = 10;
const ushort Quantity = 1000;
var tradeRecordingService = Substitute.For <ITradeRecordingService>();
var position = new PositionItem
{
Quantity = Quantity,
Symbol = new Symbol
{
Code = Symbol
}
};
var vm = GetVm(tradeRecordingService: tradeRecordingService);
vm.Positions.Add(position);
// Act
var msg = new OrderStatusEventArgs(1, BrokerConstants.OrderStatus.Filled, Quantity, 0, FillPrice, 0, 0, FillPrice, 0, null);
var message = new OrderStatusChangedMessage(Symbol, msg);
Messenger.Default.Send(message, OrderStatusChangedMessage.Tokens.Positions);
// Assert
await tradeRecordingService.Received().ExitTradeAsync(
Arg.Is <PositionItem>(x => x == position),
Arg.Is <OrderStatusChangedMessage>(x => x == message));
}
public void WhenOrderCancelledViaTwsStatusIsUpdatedAndFindAndSubmitDisabled()
{
// Arrange
const string Symbol = "AMZN";
var orderCalculationService = Substitute.For <IOrderCalculationService>();
var vm = GetStandardVm(orderCalculationService, FindCommandResults(), Symbol);
var findCommandCanExecuteChangedFired = false;
var submitCommandCanExecuteChangedFired = false;
vm.SubmitCommand.CanExecuteChanged += (sender, e) => submitCommandCanExecuteChangedFired = true;
vm.FindCommand.CanExecuteChanged += (sender, e) => findCommandCanExecuteChangedFired = true;
// Act
var msg = new OrderStatusEventArgs(1, BrokerConstants.OrderStatus.Cancelled, 0, 0, 0, 1, 0, 0, 0, null);
Messenger.Default.Send(new OrderStatusChangedMessage(Symbol, msg), OrderStatusChangedMessage.Tokens.Orders);
// Assert
Assert.Equal(OrderStatus.Cancelled, vm.Status);
Assert.False(vm.SubmitCommand.CanExecute());
Assert.True(submitCommandCanExecuteChangedFired);
Assert.False(vm.FindCommand.CanExecute());
Assert.True(findCommandCanExecuteChangedFired);
Assert.True(vm.IsLocked);
}
private void HandleOrderStatus(object sender, OrderStatusEventArgs args)
{
var orderId = args.OrderId;
Log.Debug("Order status: {0}, permid: {1}, orderid: {2}", args.Status, args.PermId, orderId);
if (_orders.ContainsKey(orderId))
{
var symbol = _orders[orderId];
_queueProcessor.Enqueue(() => Messenger.Default.Send(new OrderStatusChangedMessage(symbol, args), OrderStatusChangedMessage.Tokens.Orders));
}
}
public void WhenOrderFilledTradeAddedAndMessageForwardedOntoMainViewModel()
{
// Arrange
const string Symbol = "AMZN";
const int OrderId = 1;
const int Quantity = 99;
const double FillPrice = 12.03;
const double StopPrice = 10;
var tradeRepository = Substitute.For <ITradeRepository>();
var orderManager = Substitute.For <IOrderManager>();
var vm = GetVm(tradeRepository, orderManager: orderManager);
vm.AddOrder(new Symbol(), new FindCommandResultsModel());
var order = vm.Orders[0];
order.Status = OrderStatus.Filled;
order.Symbol.Code = Symbol;
order.Id = OrderId;
order.Quantity = Quantity;
order.InitialStopLossPrice = StopPrice;
var fired = false;
Messenger.Default.Register <OrderStatusChangedMessage>(this, OrderStatusChangedMessage.Tokens.Main, msg => fired = true);
// Act
var msg = new OrderStatusEventArgs(OrderId, BrokerConstants.OrderStatus.Filled, 0, 0, FillPrice, 1, 0, FillPrice, 0, null);
Messenger.Default.Send(new OrderStatusChangedMessage(Symbol, msg), OrderStatusChangedMessage.Tokens.Orders);
// Assert
tradeRepository.Received().AddTradeAsync(Arg.Is <Trade>(x =>
x.Symbol == Symbol &&
x.Quantity == Quantity &&
x.Direction == Direction.Buy &&
x.EntryPrice == FillPrice &&
!x.ExitPrice.HasValue &&
!x.ExitTimeStamp.HasValue));
Assert.True(fired);
// Check stop order
orderManager.Received().PlaceNewOrderAsync(Arg.Is <Contract>(x => x.Symbol == Symbol), Arg.Is <Order>(o =>
o.OrderType == BrokerConstants.OrderTypes.Stop &&
o.Action == BrokerConstants.Actions.Sell &&
o.TotalQuantity == Quantity &&
o.AuxPrice == StopPrice &&
o.Tif == BrokerConstants.TimeInForce.GoodTilCancelled &&
o.Transmit));
}
private void HandleOrderStatus(OrderStatusEventArgs args)
{
var orderId = args.OrderId;
// We only care about the status of the trailing stop orders
var orders = _orderMessages.Where(o => o.OrderId == orderId && o.Order.OrderType == BrokerConstants.OrderTypes.Trail)
.ToList();
foreach (var openOrder in orders)
{
LogOrder(openOrder);
Messenger.Default.Send(new OrderStatusChangedMessage(openOrder.Contract.Symbol, args), OrderStatusChangedMessage.Tokens.Positions);
}
}
public void WhenOrderCancelledForDifferentOrderStatusIsNotUpdated()
{
// Arrange
const string Symbol = "AMZN";
var orderCalculationService = Substitute.For <IOrderCalculationService>();
var vm = GetStandardVm(orderCalculationService, FindCommandResults(), Symbol + "different");
// Act
var msg = new OrderStatusEventArgs(1, BrokerConstants.OrderStatus.Cancelled, 0, 0, 0, 1, 0, 0, 0, null);
Messenger.Default.Send(new OrderStatusChangedMessage(Symbol, msg), OrderStatusChangedMessage.Tokens.Orders);
// Assert
Assert.Equal(OrderStatus.Pending, vm.Status);
}
private void client_OrderStatus(object sender, OrderStatusEventArgs e)
{
if (trace)
{
log.Trace("Order Status for Id " + e.OrderId + " is " + e.Status);
}
bool deleteFlag = false;
switch (e.Status)
{
case OrderStatus.Canceled:
case OrderStatus.Filled:
case OrderStatus.Inactive:
case OrderStatus.PendingCancel:
deleteFlag = true;
break;
case OrderStatus.ApiPending:
case OrderStatus.PendingSubmit:
case OrderStatus.PreSubmitted:
case OrderStatus.PartiallyFilled:
case OrderStatus.Submitted:
// LogicalOrderHandler will decide what to do with these.
break;
default:
log.Error("Unexpected order status: " + e.Status);
break;
}
if (deleteFlag)
{
if (openOrders.ContainsKey(e.OrderId))
{
openOrders.Remove(e.OrderId);
}
if (trace)
{
log.Trace("Removing open order id " + e.OrderId);
}
}
}
public async Task WhenOrderStatusChangedAndNotFilledDoNotRecordTradeExitAsync()
{
// Arrange
const double FillPrice = 10;
const ushort Quantity = 1000;
var tradeRecordingService = Substitute.For <ITradeRecordingService>();
GetVm(tradeRecordingService: tradeRecordingService);
// Act
var msg = new OrderStatusEventArgs(1, BrokerConstants.OrderStatus.Cancelled, Quantity, 0, FillPrice, 0, 0, FillPrice, 0, null);
var message = new OrderStatusChangedMessage(Symbol, msg);
Messenger.Default.Send(message, OrderStatusChangedMessage.Tokens.Positions);
// Assert
await tradeRecordingService.DidNotReceive().ExitTradeAsync(
Arg.Any <PositionItem>(),
Arg.Any <OrderStatusChangedMessage>());
}
/// <inheritdoc/>
public void orderStatus(int orderId, string status, double filled, double remaining, double avgFillPrice, int permId, int parentId, double lastFillPrice, int clientId, string whyHeld, double mktCapPrice)
{
var eventArgs = new OrderStatusEventArgs(orderId, status, filled, remaining, avgFillPrice, permId, parentId, lastFillPrice, clientId, whyHeld);
this.OrderStatusEvent?.Invoke(this, eventArgs);
}
static void client_OrderStatus(object sender, OrderStatusEventArgs e)
{
Console.WriteLine("Order Placed.");
}
public OrderStatusChangedMessage(string symbol, OrderStatusEventArgs message)
: base(symbol)
{
Message = message;
}
private void HandleOrderStatusEvent(object sender, OrderStatusEventArgs args)
{
// Hand off processing to the queue processor to improve perf of the API processing loop
_queueProcessor.Enqueue(() => HandleOrderStatus(args));
}
void ibclient_OrderStatus(object sender, OrderStatusEventArgs e)
{
try
{
ibclient_OrderStatus2(sender, e);
}
catch (Exception ex)
{
error("ibclient_OrderStatus: Exception: " + ex.Message + Environment.NewLine + ex.StackTrace);
}
}
void ibclient_OrderStatus2(object sender, OrderStatusEventArgs e)
{
tStart("ibclient_OrderStatus()");
logger.AddLog(LoggerLevel.Information,
"ibclient_OrderStatus: received from TWS "
+ " ID: " + e.OrderId.ToString()
+ ", ClientID: " + e.ClientId.ToString()
+ ", Filled: " + e.Filled.ToString()
+ ", Remaining: " + e.Remaining
+ ", Status: " + e.Status);
if (e.ClientId != clientId)
{
error("OrderStatus: Client Id mismatch: " + e.ClientId.ToString());
tEnd("ibclient_OrderStatus() bad clientId");
return;
}
string orderId = e.OrderId.ToString();
switch (e.Status)
{
case IB.OrderStatus.ApiCancelled:
case IB.OrderStatus.Canceled:
OnOrderCanceled(orderId);
break;
case IB.OrderStatus.ApiPending:
case IB.OrderStatus.PreSubmitted:
case IB.OrderStatus.PendingSubmit:
case IB.OrderStatus.Submitted:
case IB.OrderStatus.Filled:
case IB.OrderStatus.PartiallyFilled:
bool sendAccepted = false;
lock(private_lock)
{
if (workingOrders.ContainsKey(orderId) &&
workingOrders[orderId].state == SrOrderInfoState.New)
sendAccepted = true;
}
if(sendAccepted) OnOrderAccepted(orderId);
if (e.Filled > 0)
{
bool completely_filled = e.Status == IB.OrderStatus.Filled;
OnOrderFilled(orderId, e.Filled, e.Remaining, (double)e.LastFillPrice, completely_filled);
}
break;
case IB.OrderStatus.PendingCancel:
OnOrderPendingCancel(orderId);
break;
default:
case IB.OrderStatus.Unknown:
case IB.OrderStatus.None:
case IB.OrderStatus.Inactive:
OnOrderError(orderId, "unexpected order status " + e.Status.ToString());
break;
}
tEnd("ibclient_OrderStatus()");
}
