// ****************
public GridWindow(Option StartUpOptions)
{
_startUpOption = StartUpOptions;
_exe = new NewExecution( StartUpOptions );
_exe.TaskCompleted += ProgressChanged;
OwnPacketReceiver.EndOfScan += ScanEnded;
InitializeComponent();
InitializeComboBox();
InitializeDataGridView();
}
public void TryMatch(ILimitOrder buyLimitOrder, ILimitOrder sellLimitOrder)
{
/*if (buyLimitOrder.ClientId == sellLimitOrder.ClientId)
* return;*/
if (buyLimitOrder.Symbol != sellLimitOrder.Symbol)
{
return;
}
if (buyLimitOrder.Price < sellLimitOrder.Price)
{
return;
}
if (buyLimitOrder.Quantity == 0 || sellLimitOrder.Quantity == 0)
{
return;
}
double matchPrice = FindMatchPrice(buyLimitOrder, sellLimitOrder);
int matchQuantity = FindMatchQuantity(buyLimitOrder, sellLimitOrder);
if (matchQuantity == 0)
{
return;
}
buyLimitOrder.Modify(buyLimitOrder.Quantity - matchQuantity);
sellLimitOrder.Modify(sellLimitOrder.Quantity - matchQuantity);
var execution = new NewExecution(buyLimitOrder, sellLimitOrder, matchQuantity, matchPrice, dateService.UtcNow());
for (int i = 0; i < executionHandlers.Count; i++)
{
executionHandlers[i].Invoke(execution);
}
}
/// <summary>
/// New Tick Arrived from Simulated Market Data Exchange
/// </summary>
/// <param name="tick"></param>
public void NewTickArrived(Tick tick)
{
try
{
lock (_marketOrders)
{
var selectedlist = _marketOrders.Where(x => x.Security.Symbol == tick.Security.Symbol);
foreach (var marketOrder in selectedlist)
{
_marketOrders.Remove(marketOrder);
var newExecution =
new Execution(
new Fill(marketOrder.Security, marketOrder.OrderExecutionProvider,
marketOrder.OrderID)
{
ExecutionDateTime = tick.DateTime,
ExecutionPrice = tick.LastPrice,
ExecutionSize = marketOrder.OrderSize,
AverageExecutionPrice = tick.LastPrice,
ExecutionId = Guid.NewGuid().ToString(),
ExecutionSide = marketOrder.OrderSide,
ExecutionType = ExecutionType.Fill,
LeavesQuantity = 0,
OrderExecutionProvider = OrderExecutionProvider.SimulatedExchange,
CummalativeQuantity = marketOrder.OrderSize
}, marketOrder);
if (NewExecution != null)
{
NewExecution.Invoke(newExecution);
}
}
}
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "NewTickArrived");
}
}
public void TryMatch(ILimitOrder buyLimitOrder, IMarketOrder sellMarketOrder)
{
if (sellMarketOrder.Way != WayEnum.Sell || buyLimitOrder.Way != WayEnum.Buy)
{
return;
}
if (sellMarketOrder.Symbol != buyLimitOrder.Symbol)
{
return;
}
if (sellMarketOrder.Quantity == 0 || buyLimitOrder.Quantity == 0)
{
return;
}
int matchQuantity = FindMatchQuantity(sellMarketOrder, buyLimitOrder);
if (matchQuantity == 0)
{
return;
}
double matchPrice = buyLimitOrder.Price;
sellMarketOrder.Modify(sellMarketOrder.Quantity - matchQuantity);
buyLimitOrder.Modify(buyLimitOrder.Quantity - matchQuantity);
var execution = new NewExecution(buyLimitOrder, sellMarketOrder, matchQuantity, matchPrice, dateService.UtcNow());
for (int i = 0; i < executionHandlers.Count; i++)
{
executionHandlers[i].Invoke(execution);
}
}
/// <summary>
/// Executes accepted market order
/// </summary>
/// <param name="limitOrder">TradeHub Limit Order</param>
private void ExecuteLimitOrder(LimitOrder limitOrder)
{
try
{
DateTime[] ticksCollectionKeys;
lock (_ticksCollection)
{
ticksCollectionKeys = _ticksCollection.Keys.ToArray();
}
foreach (DateTime key in ticksCollectionKeys)
{
if (key > limitOrder.OrderDateTime)
{
Tick tick;
if (_ticksCollection.TryGetValue(key, out tick))
{
#region BUY Order
if (limitOrder.OrderSide == OrderSide.BUY &&
tick.LastPrice <= limitOrder.LimitPrice)
{
var newExecution =
new Execution(
new Fill(limitOrder.Security, limitOrder.OrderExecutionProvider,
limitOrder.OrderID)
{
ExecutionDateTime = tick.DateTime,
ExecutionPrice = limitOrder.LimitPrice,
ExecutionSize = limitOrder.OrderSize,
AverageExecutionPrice = tick.LastPrice,
ExecutionId = Guid.NewGuid().ToString(),
ExecutionSide = limitOrder.OrderSide,
ExecutionType = ExecutionType.Fill,
LeavesQuantity = 0,
OrderExecutionProvider = OrderExecutionProvider.SimulatedExchange,
CummalativeQuantity = limitOrder.OrderSize
}, limitOrder);
if (NewExecution != null)
{
NewExecution.Invoke(newExecution);
}
if (Logger.IsDebugEnabled)
{
Logger.Debug("Limit Order Executed using:" + tick, _type.FullName, "ExecuteLimitOrder");
}
return;
}
#endregion
#region SELL Order
if (limitOrder.OrderSide == OrderSide.SELL &&
tick.LastPrice > limitOrder.LimitPrice)
{
var newExecution =
new Execution(
new Fill(limitOrder.Security, limitOrder.OrderExecutionProvider,
limitOrder.OrderID)
{
ExecutionDateTime = tick.DateTime,
ExecutionPrice = limitOrder.LimitPrice,
ExecutionSize = limitOrder.OrderSize,
AverageExecutionPrice = tick.LastPrice,
ExecutionId = Guid.NewGuid().ToString(),
ExecutionSide = limitOrder.OrderSide,
ExecutionType = ExecutionType.Fill,
LeavesQuantity = 0,
OrderExecutionProvider = OrderExecutionProvider.SimulatedExchange,
CummalativeQuantity = limitOrder.OrderSize
}, limitOrder);
if (NewExecution != null)
{
NewExecution.Invoke(newExecution);
}
if (Logger.IsDebugEnabled)
{
Logger.Debug("Limit Order Executed using:" + tick, _type.FullName, "ExecuteLimitOrder");
}
return;
}
#endregion
}
}
}
//foreach (KeyValuePair<DateTime, Tick> keyValuePair in _ticksCollection)
//{
// if (keyValuePair.Key > limitOrder.OrderDateTime)
// {
// #region BUY Order
// if (limitOrder.OrderSide == OrderSide.BUY &&
// keyValuePair.Value.LastPrice <= limitOrder.LimitPrice)
// {
// var newExecution =
// new Execution(
// new Fill(limitOrder.Security, limitOrder.OrderExecutionProvider,
// limitOrder.OrderID)
// {
// ExecutionDateTime = keyValuePair.Value.DateTime,
// ExecutionPrice = limitOrder.LimitPrice,
// ExecutionSize = limitOrder.OrderSize,
// AverageExecutionPrice = keyValuePair.Value.LastPrice,
// ExecutionId = Guid.NewGuid().ToString(),
// ExecutionSide = limitOrder.OrderSide,
// ExecutionType = ExecutionType.Fill,
// LeavesQuantity = 0,
// OrderExecutionProvider = OrderExecutionProvider.SimulatedExchange,
// CummalativeQuantity = limitOrder.OrderSize
// }, limitOrder);
// if (NewExecution != null)
// {
// NewExecution.Invoke(newExecution);
// }
// if (Logger.IsDebugEnabled)
// {
// Logger.Debug("Limit Order Executed using:" + keyValuePair.Value, _type.FullName,
// "ExecuteLimitOrder");
// }
// return;
// }
// #endregion
// #region SELL Order
// if (limitOrder.OrderSide == OrderSide.SELL &&
// keyValuePair.Value.LastPrice > limitOrder.LimitPrice)
// {
// var newExecution =
// new Execution(
// new Fill(limitOrder.Security, limitOrder.OrderExecutionProvider,
// limitOrder.OrderID)
// {
// ExecutionDateTime = keyValuePair.Value.DateTime,
// ExecutionPrice = limitOrder.LimitPrice,
// ExecutionSize = limitOrder.OrderSize,
// AverageExecutionPrice = keyValuePair.Value.LastPrice,
// ExecutionId = Guid.NewGuid().ToString(),
// ExecutionSide = limitOrder.OrderSide,
// ExecutionType = ExecutionType.Fill,
// LeavesQuantity = 0,
// OrderExecutionProvider = OrderExecutionProvider.SimulatedExchange,
// CummalativeQuantity = limitOrder.OrderSize
// }, limitOrder);
// if (NewExecution != null)
// {
// NewExecution.Invoke(newExecution);
// }
// if (Logger.IsDebugEnabled)
// {
// Logger.Debug("Limit Order Executed using:" + keyValuePair.Value, _type.FullName,
// "ExecuteLimitOrder");
// }
// return;
// }
// #endregion
// }
//}
// Add to List
_limitOrders.Add(limitOrder);
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "ExecuteLimitOrder");
}
}
/// <summary>
/// New Are Arrived From Simulated data service.
/// </summary>
/// <param name="bar"></param>
public void NewBarArrived(Bar bar)
{
try
{
lock (_limitOrders)
{
var selectedlist = _limitOrders.Where(x => x.Security.Symbol == bar.Security.Symbol);
foreach (var limitOrder in selectedlist.ToList())
{
if (limitOrder.Security.Symbol == bar.Security.Symbol)
{
if (limitOrder.OrderSide == OrderSide.BUY && bar.Low <= limitOrder.LimitPrice)
{
var newExecution =
new Execution(
new Fill(limitOrder.Security, limitOrder.OrderExecutionProvider,
limitOrder.OrderID)
{
DateTime = bar.DateTime,
ExecutionPrice = limitOrder.LimitPrice,
ExecutionSize = limitOrder.OrderSize,
AverageExecutionPrice = bar.Close,
ExecutionId = Guid.NewGuid().ToString(),
ExecutionSide = limitOrder.OrderSide,
ExecutionType = ExecutionType.Fill,
LeavesQuantity = 0,
OrderExecutionProvider = OrderExecutionProvider.SimulatedExchange,
CummalativeQuantity = limitOrder.OrderSize
}, limitOrder);
if (NewExecution != null)
{
NewExecution.Invoke(newExecution);
}
_limitOrders.Remove(limitOrder);
}
if (limitOrder.OrderSide == OrderSide.SELL && bar.Low > limitOrder.LimitPrice)
{
var newExecution =
new Execution(
new Fill(limitOrder.Security, limitOrder.OrderExecutionProvider,
limitOrder.OrderID)
{
DateTime = bar.DateTime,
ExecutionPrice = limitOrder.LimitPrice,
ExecutionSize = limitOrder.OrderSize,
AverageExecutionPrice = bar.Close,
ExecutionId = Guid.NewGuid().ToString(),
ExecutionSide = limitOrder.OrderSide,
ExecutionType = ExecutionType.Fill,
LeavesQuantity = 0,
OrderExecutionProvider = OrderExecutionProvider.SimulatedExchange,
CummalativeQuantity = limitOrder.OrderSize
}, limitOrder);
if (NewExecution != null)
{
NewExecution.Invoke(newExecution);
}
_limitOrders.Remove(limitOrder);
}
}
}
}
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "NewBarArrived");
}
}
public static void ConsoleMain( string[] startupArgs, Option StartupOptions )
{
Arguments args = new Arguments( startupArgs );
Console.Title = "GridMapper";
if ( StartupOptions.CmdConsole )
{
ConsoleHelper.DeletePath();
}
bool console = StartupOptions.CmdConsole;
int maxTasks;
//help message get priority over everything
if ( args.IsTrue( "h" ) || args.IsTrue( "?" ) || args.IsTrue( "help" ) ||
args.Exists( "h" ) || args.Exists( "?" ) || args.Exists( "help" ) )
{
ConsoleHelper.PrintHelp();
}
else
{
Repository.OnRepositoryUpdated += DoNothing;
OwnPacketReceiver.EndOfScan += ScanEnded;
t.Interval = 50;
t.Elapsed += timer_Tick;
StartupOptions.CmdConsole = true;
if ( args.IsTrue( "auto" ) || args.Exists( "auto" ) )
{
_exe = new NewExecution( StartupOptions );
_exe.TaskCompleted += ProgressChanged;
LaunchScan();
}
else
{
if ( args.Exists( "IP" ) )
{
IPParserResult Ips = IPParser.TryParse( args.Single( "IP" ) );
if ( Ips.HasError == true )
{
Console.WriteLine( "Not a valid input for IP" );
}
else
{
StartupOptions.IpToTest = Ips;
}
}
//if ( args.Exists( "p" ) )
//{
//PortsParserResult PortsToHandle = PortsParser.MainPortsParser(args.Single("p"));
//IEnumerator enumerator = PortsToHandle.Result.GetEnumerator();
//}
//if ( args.Exists( "t" ) || args.Exists( "tasks" ) )
//{
// if ( int.TryParse( args.Single( "t" ), out maxTasks ) || int.TryParse( args.Single( "tasks" ), out maxTasks ) )
// {
// if ( maxTasks >= 1 && maxTasks <= 2000 )
// {
// StartupOptions.MaximumTasks = maxTasks;
// }
// else
// {
// Console.WriteLine( "The number of tasks must be between 1 and 2000, reasonnable limit is around 4" );
// }
// }
// else
// {
// Console.WriteLine( "Invalid argument for -t" );
// }
//}
_exe = new NewExecution( StartupOptions );
_exe.TaskCompleted += ProgressChanged;
LaunchScan();
}
}
if ( console )
{
ConsoleHelper.ShowPath();
}
else
{
ConsoleHelper.EndOfProgram();
}
}
/// <summary>
/// Executes accepted market order
/// </summary>
/// <param name="marketOrder">TradeHub Market Order</param>
private void ExecuteMarketOrder(MarketOrder marketOrder)
{
try
{
Tick tick = null;
DateTime key;
if (marketOrder.OrderDateTime.Hour.Equals(15) && marketOrder.OrderDateTime.Minute.Equals(58) && marketOrder.OrderDateTime.Second.Equals(56))
{
key = marketOrder.OrderDateTime.AddHours(17);
key = key.AddMinutes(32);
key = key.AddSeconds(-42);
}
else if (marketOrder.OrderDateTime.Second == 56 || marketOrder.OrderDateTime.Second == 11)
{
key = marketOrder.OrderDateTime.AddSeconds(18);
}
else
{
key = marketOrder.OrderDateTime.AddSeconds(14);
}
#region Create Execution Message
while (true)
{
if (_ticksCollection.TryGetValue(key, out tick))
{
var newExecution =
new Execution(
new Fill(marketOrder.Security, marketOrder.OrderExecutionProvider,
marketOrder.OrderID)
{
ExecutionDateTime = tick.DateTime,
ExecutionPrice = tick.LastPrice,
ExecutionSize = marketOrder.OrderSize,
AverageExecutionPrice = tick.LastPrice,
ExecutionId = Guid.NewGuid().ToString(),
ExecutionSide = marketOrder.OrderSide,
ExecutionType = ExecutionType.Fill,
LeavesQuantity = 0,
OrderExecutionProvider = OrderExecutionProvider.SimulatedExchange,
CummalativeQuantity = marketOrder.OrderSize
}, marketOrder);
if (NewExecution != null)
{
NewExecution.Invoke(newExecution);
}
if (Logger.IsDebugEnabled)
{
Logger.Debug("Market Order Executed using:" + tick, _type.FullName, "ExecuteMarketOrder");
}
break;
}
// Try to get the tick from next minute if the key is not found
key = key.AddMinutes(1);
}
#endregion
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "ExecuteMarketOrder");
}
}
