public ActionResult Cancel(int id)
{
var result = _ordersService.CancelOrder(id);
if (result == ChangeOrderStatusResult.InvalidStatus)
{
return(View("InvalidStatus"));
}
if (result == ChangeOrderStatusResult.NotFound)
{
return(HttpNotFound());
}
return(RedirectToAction("Index"));
}
public ActionResult Cancel(int id)
{
var cc = DateTime.Now - ordersService.GetOrderById(id).Created;
string Message = "";
if (cc.Minutes <= 10)
{
ordersService.CancelOrder(id);
Message = "That order has been canceled sir :)";
}
else
{
Message = "You cannot cancel orders older than 10 minutes.";
}
return(Content(Message));
}
public async Task <TradingPosition> ProcessTradingPositionChanging(TradingPosition currentState,
TradingPosition nextState,
bool syncWithStock,
Action <PositionChangedEventArgs> onPositionChangedCallback)
{
if (syncWithStock)
{
try
{
nextState.StopLossOrder = await _ordersService.CancelOrder(currentState.StopLossOrder);
}
catch (ConnectorException e)
{
if (e.Message?.Contains("Order not found") ?? false)
{
var activeOrders = await _ordersService.GetActiveOrders(currentState.StopLossOrder.CurrencyPair);
var serverSideStopLossOrder = activeOrders.FirstOrDefault(order => order.ClientId == currentState.StopLossOrder.ClientId) ??
await _ordersService.GetOrderFromHistory(currentState.StopLossOrder.ClientId, currentState.StopLossOrder.CurrencyPair);
if (serverSideStopLossOrder != null)
{
if (serverSideStopLossOrder.OrderStateType == OrderStateType.Filled)
{
nextState.StopLossOrder.SyncWithAnotherOrder(serverSideStopLossOrder);
var nextProcessor = new StopLossOrderFillingProcessor(_orderRepository, _ordersService, _loggingService);
return(await nextProcessor.ProcessTradingPositionChanging(currentState, nextState, true, onPositionChangedCallback));
}
if (serverSideStopLossOrder.OrderStateType == OrderStateType.Cancelled || serverSideStopLossOrder.OrderStateType == OrderStateType.Expired)
{
nextState.StopLossOrder.SyncWithAnotherOrder(serverSideStopLossOrder);
}
else
{
throw;
}
}
else
{
throw;
}
}
else
{
throw;
}
}
}
nextState.StopLossOrder.OrderStateType = OrderStateType.Cancelled;
if (currentState.ClosePositionOrder.OrderStateType != OrderStateType.Filled)
{
if (!(currentState.ClosePositionOrder.OrderStateType == OrderStateType.Pending ||
currentState.ClosePositionOrder.OrderStateType == OrderStateType.Cancelled ||
currentState.ClosePositionOrder.OrderStateType == OrderStateType.Expired))
{
try
{
await _ordersService.CancelOrder(currentState.ClosePositionOrder);
}
catch
{
// ignored
}
finally
{
nextState.ClosePositionOrder.OrderStateType = OrderStateType.Cancelled;
}
}
var immediateCloseOrder = new Order
{
ClientId = Guid.NewGuid(),
CurrencyPair = currentState.ClosePositionOrder.CurrencyPair,
Role = OrderRoleType.ClosePosition,
OrderSide = currentState.ClosePositionOrder.OrderSide,
OrderType = OrderType.Market,
OrderStateType = OrderStateType.New,
TimeInForce = OrderTimeInForceType.GoodTillCancelled
};
var serverSideOrder = await _ordersService.CreateSellMarketOrder(immediateCloseOrder);
if (serverSideOrder.OrderStateType != OrderStateType.Filled)
{
throw new BusinessException("Unexpected order state found")
{
Details = $"Close position market order: {JsonConvert.SerializeObject(serverSideOrder)}"
}
}
;
}
var stopLossOrderEntity = _orderRepository.Get(nextState.StopLossOrder.Id);
if (stopLossOrderEntity == null)
{
throw new BusinessException("Order was not found in storage")
{
Details = $"Stop loss order: {JsonConvert.SerializeObject(nextState.StopLossOrder)}"
}
}
;
_orderRepository.Update(nextState.StopLossOrder.ToEntity(stopLossOrderEntity));
_loggingService.LogAction(nextState.ClosePositionOrder.ToLogAction(OrderActionType.Cancel));
return(nextState);
}
}
}
public async Task <TradingPosition> ProcessTradingPositionChanging(TradingPosition currentState,
TradingPosition nextState,
bool syncWithStock,
Action <PositionChangedEventArgs> onPositionChangedCallback)
{
if (nextState.OpenPositionOrder.OrderStateType == OrderStateType.PartiallyFilled)
{
try
{
await _ordersService.CancelOrder(currentState.OpenPositionOrder);
}
catch (ConnectorException e)
{
if (e.Message?.Contains("Order not found") ?? false)
{
var activeOrders = await _ordersService.GetActiveOrders(currentState.OpenPositionOrder.CurrencyPair);
var serverSideOpenPositionOrder = activeOrders.FirstOrDefault(order => order.ClientId == currentState.OpenPositionOrder.ClientId) ??
await _ordersService.GetOrderFromHistory(currentState.OpenPositionOrder.ClientId, currentState.OpenPositionOrder.CurrencyPair);
if (serverSideOpenPositionOrder?.OrderStateType != OrderStateType.Filled)
{
throw;
}
}
else
{
throw;
}
}
nextState.OpenPositionOrder.OrderStateType = OrderStateType.Filled;
}
nextState.StopLossOrder.OrderStateType = OrderStateType.Suspended;
nextState.StopLossOrder = await _ordersService.CreateSellMarketOrder(nextState.StopLossOrder);
var openOrderEntity = _orderRepository.Get(nextState.OpenPositionOrder.Id);
if (openOrderEntity == null)
{
throw new BusinessException("Order was not found in storage")
{
Details = $"Open position order: {JsonConvert.SerializeObject(nextState.OpenPositionOrder)}"
}
}
;
_orderRepository.Update(nextState.OpenPositionOrder.ToEntity(openOrderEntity));
_loggingService.LogAction(nextState.OpenPositionOrder.ToLogAction(OrderActionType.Fill));
var stopLossOrderEntity = _orderRepository.Get(nextState.StopLossOrder.Id);
if (stopLossOrderEntity == null)
{
throw new BusinessException("Order was not found in storage")
{
Details = $"Stop loss order: {JsonConvert.SerializeObject(nextState.StopLossOrder)}"
}
}
;
_orderRepository.Update(nextState.StopLossOrder.ToEntity(stopLossOrderEntity));
_loggingService.LogAction(nextState.StopLossOrder.ToLogAction(OrderActionType.Create));
onPositionChangedCallback?.Invoke(new PositionChangedEventArgs(TradingEventType.PositionOpened, nextState));
return(nextState);
}
}
}
public async Task <TradingPosition> ProcessTradingPositionChanging(TradingPosition currentState,
TradingPosition nextState,
bool syncWithStock,
Action <PositionChangedEventArgs> onPositionChangedCallback)
{
if (syncWithStock)
{
try
{
nextState.OpenPositionOrder = await _ordersService.CancelOrder(currentState.OpenPositionOrder);
}
catch (ConnectorException e)
{
if (e.Message?.Contains("Order not found") ?? false)
{
var activeOrders = await _ordersService.GetActiveOrders(currentState.OpenPositionOrder.CurrencyPair);
var serverSideOpenPositionOrder = activeOrders.FirstOrDefault(order => order.ClientId == currentState.OpenPositionOrder.ClientId) ??
await _ordersService.GetOrderFromHistory(currentState.OpenPositionOrder.ClientId, currentState.OpenPositionOrder.CurrencyPair);
if (serverSideOpenPositionOrder != null)
{
if (serverSideOpenPositionOrder.OrderStateType == OrderStateType.Filled)
{
nextState.OpenPositionOrder.SyncWithAnotherOrder(serverSideOpenPositionOrder);
var nextProcessor = new BuyOrderFillingProcessor(_orderRepository, _ordersService, _loggingService);
return(await nextProcessor.ProcessTradingPositionChanging(currentState, nextState, true, onPositionChangedCallback));
}
if (serverSideOpenPositionOrder.OrderStateType == OrderStateType.Cancelled || serverSideOpenPositionOrder.OrderStateType == OrderStateType.Expired)
{
nextState.OpenPositionOrder.SyncWithAnotherOrder(serverSideOpenPositionOrder);
}
else
{
throw;
}
}
else
{
throw;
}
}
else
{
throw;
}
}
}
var openOrderEntity = _orderRepository.Get(nextState.OpenPositionOrder.Id);
if (openOrderEntity == null)
{
throw new BusinessException("Order was not found in storage")
{
Details = $"Open position order: {JsonConvert.SerializeObject(nextState.OpenPositionOrder)}"
}
}
;
_orderRepository.Update(nextState.OpenPositionOrder.ToEntity(openOrderEntity));
_loggingService.LogAction(nextState.OpenPositionOrder.ToLogAction(nextState.OpenPositionOrder.OrderStateType == OrderStateType.Cancelled ? OrderActionType.Cancel : OrderActionType.Update));
if (nextState.OpenPositionOrder.OrderStateType == OrderStateType.Cancelled)
{
onPositionChangedCallback?.Invoke(new PositionChangedEventArgs(TradingEventType.PositionCancelled, nextState));
}
return(nextState);
}
}
public async Task <TradingPosition> ProcessTradingPositionChanging(TradingPosition currentState,
TradingPosition nextState,
bool syncWithStock,
Action <PositionChangedEventArgs> onPositionChangedCallback)
{
if (syncWithStock && currentState.ClosePositionOrder.OrderStateType != OrderStateType.Pending)
{
try
{
await _ordersService.CancelOrder(currentState.ClosePositionOrder);
}
catch (ConnectorException e)
{
if (e.Message?.Contains("Order not found") ?? false)
{
var activeOrders = await _ordersService.GetActiveOrders(currentState.ClosePositionOrder.CurrencyPair);
var serverSideClosePositionOrder = activeOrders.FirstOrDefault(order => order.ClientId == currentState.ClosePositionOrder.ClientId) ??
await _ordersService.GetOrderFromHistory(currentState.ClosePositionOrder.ClientId, currentState.ClosePositionOrder.CurrencyPair);
if (serverSideClosePositionOrder?.OrderStateType != OrderStateType.Filled)
{
throw;
}
}
else
{
throw;
}
}
}
if (!(nextState.StopLossOrder.OrderStateType == OrderStateType.Pending ||
nextState.StopLossOrder.OrderStateType == OrderStateType.Cancelled ||
nextState.StopLossOrder.OrderStateType == OrderStateType.Expired))
{
try
{
await _ordersService.CancelOrder(currentState.StopLossOrder);
}
catch
{
// ignored
}
finally
{
nextState.StopLossOrder.OrderStateType = OrderStateType.Cancelled;
}
}
var closeOrderEntity = _orderRepository.Get(nextState.ClosePositionOrder.Id);
if (closeOrderEntity == null)
{
throw new BusinessException("Order was not found in storage")
{
Details = $"Close position order: {JsonConvert.SerializeObject(nextState.ClosePositionOrder)}"
}
}
;
_orderRepository.Update(nextState.ClosePositionOrder.ToEntity(closeOrderEntity));
_loggingService.LogAction(nextState.ClosePositionOrder.ToLogAction(OrderActionType.Fill));
var stopLossOrderEntity = _orderRepository.Get(nextState.StopLossOrder.Id);
if (stopLossOrderEntity == null)
{
throw new BusinessException("Order was not found in storage")
{
Details = $"Stop loss order: {JsonConvert.SerializeObject(nextState.StopLossOrder)}"
}
}
;
_orderRepository.Update(nextState.StopLossOrder.ToEntity(stopLossOrderEntity));
_loggingService.LogAction(nextState.StopLossOrder.ToLogAction(OrderActionType.Cancel));
return(nextState);
}
}
}
public void CancelOrder(int orderId)
{
_ordersService.CancelOrder(orderId);
}
