/// <summary>
/// Launches the IQ Feed Connector form and starts connection
/// </summary>
/// <param name="loginId">Login ID</param>
/// <param name="password">Password</param>
/// <param name="productId">Product ID provided by IQ for the give Login ID</param>
/// <param name="productVersion">Prouct version of the IQ Feed Connector installed</param>
/// <returns></returns>
public bool Connect(string loginId, string password, string productId, string productVersion)
{
try
{
_loginId = loginId;
_password = password;
_productId = productId;
_productVersion = productVersion;
if (LaunchForm())
{
// Opens connections with the Form
CreateConnection();
return(true);
}
return(false);
}
catch (Exception exception)
{
_logger.Error(exception, _type.FullName, "LaunchForm");
return(false);
}
}
/// <summary>
/// Reads OEE MQ parameters from the Config file
/// </summary>
private void ReadOeeMqServerConfigSettings()
{
try
{
if (File.Exists(AppDomain.CurrentDomain.BaseDirectory + @"\Config\" + _oeeServerConfig))
{
var doc = new XmlDocument();
// Read Specified configuration file
doc.Load(AppDomain.CurrentDomain.BaseDirectory + @"\Config\" + _oeeServerConfig);
// Read the specified Node values
XmlNodeList nodes = doc.SelectNodes(xpath: "RabbitMQ/*");
if (nodes != null)
{
// Clear any previous values
_oeeMqServerparameters.Clear();
foreach (XmlNode node in nodes)
{
// Add value to the dictionary
_oeeMqServerparameters.Add(node.Name, node.InnerText);
}
}
return;
}
_asyncClassLogger.Info("File not found: " + _oeeServerConfig, _type.FullName, "ReadMdeMqConfigSettings");
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "ReadMdeMqConfigSettings");
}
}
/// <summary>
/// Creats market order object from incoming string message
/// </summary>
/// <param name="marketOrder">Market Order to add values to</param>
/// <param name="message">Received message</param>
/// <returns></returns>
private bool ParseToMarketOrder(MarketOrder marketOrder, string[] message)
{
try
{
// Get Order ID
marketOrder.OrderID = message[1];
// Get Order Side
marketOrder.OrderSide = message[2];
// Get Order Size
marketOrder.OrderSize = Convert.ToInt32(message[3]);
// Get Order TIF value
marketOrder.OrderTif = message[4];
// Get Symbol
marketOrder.Security = new Security()
{
Symbol = message[5]
};
// Get Time Value
marketOrder.OrderDateTime = DateTime.ParseExact(message[6], "M/d/yyyy h:mm:ss.fff tt",
CultureInfo.InvariantCulture);
// Get Order Trigger Price
marketOrder.TriggerPrice = Convert.ToDecimal(message[8]);
// Get Slippage Value
marketOrder.Slippage = Convert.ToDecimal(message[9]);
// Get Order Remarks
marketOrder.Remarks = message[10];
return(true);
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "ParseToMarketOrder");
return(false);
}
}
/// <summary>
/// Starts custom strategy execution
/// </summary>
public void ExecuteStrategy()
{
try
{
// Verify Strategy Instance
if (_tradeHubStrategy == null)
{
//create DB strategy
Strategy strategy = new Strategy();
strategy.Name = _strategyType.Name;
strategy.StartDateTime = DateTime.Now;
// Get new strategy instance
var strategyInstance = LoadCustomStrategy.CreateStrategyInstance(_strategyType, CtorArguments);
if (strategyInstance != null)
{
// Cast to TradeHubStrategy Instance
_tradeHubStrategy = strategyInstance as TradeHubStrategy;
}
if (_tradeHubStrategy == null)
{
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Unable to initialize Custom Strategy: " + _strategyType.FullName, _type.FullName, "ExecuteStrategy");
}
// Skip execution of further actions
return;
}
// Set Strategy Name
_tradeHubStrategy.StrategyName = LoadCustomStrategy.GetCustomClassSummary(_strategyType);
// Register Events
_tradeHubStrategy.OnStrategyStatusChanged += OnStrategyStatusChanged;
_tradeHubStrategy.OnNewExecutionReceived += OnNewExecutionReceived;
}
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Executing user strategy: " + _strategyType.FullName, _type.FullName, "ExecuteStrategy");
}
//Overriding if running on simulated exchange
ManageBackTestingStrategy();
// Start Executing the strategy
_tradeHubStrategy.Run();
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "ExecuteStrategy");
}
}
/// <summary>
/// Argument Constructor
/// </summary>
/// <param name="eventHandler">Event handler which will receive requested data</param>
/// <param name="localPersistance">Indicates whether the data to be saved locally on initial request</param>
public DataHandler(IEventHandler <MarketDataObject>[] eventHandler, bool localPersistance = false)
{
try
{
_classLogger = new AsyncClassLogger("SimulatedDataHandler");
// Set logging level
_classLogger.SetLoggingLevel();
//set logging path
_classLogger.LogDirectory(DirectoryStructure.CLIENT_LOGS_LOCATION);
_persistanceDataCount = 0;
_localPersistance = localPersistance;
_localPersistanceData = new SortedDictionary <int, MarketDataObject>();
_tasksCollection = new ConcurrentBag <Task>();
_fetchMarketData = new FetchData(new ReadMarketData(_classLogger), _classLogger);
// Initialize Lists
BarSubscriptionList = new List <string>();
TickSubscriptionList = new List <string>();
_fetchMarketData.InitializeDisruptor(eventHandler);
_fetchMarketData.HistoricalDataFired += HistoricDataArrived;
}
catch (Exception exception)
{
_classLogger.Error(exception, _type.FullName, "DataHandler");
}
}
public void onRequestFailed(string sRequestID, string sError)
{
if (_requestId.Equals(sRequestID))
{
_response = null;
if (string.IsNullOrEmpty(sError))
{
_logger.Error("There is no more data", _type.FullName, "onRequestFailed");
}
else
{
_logger.Error("Request failed: " + sError, _type.FullName, "onRequestFailed");
}
_syncResponseEvent.Set();
}
}
/// <summary>
/// Default Constructor
/// </summary>
public DataHandler()
{
try
{
_classLogger = new AsyncClassLogger("DataHandler");
_classLogger.SetLoggingLevel();
//set logging path
string path = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) +
"\\TradeHub Logs\\Client";
_classLogger.LogDirectory(path);
_fetchMarketData = new FetchData(new ReadMarketData(_classLogger), _classLogger);
// Initialize Lists
BarSubscriptionList = new List <string>();
TickSubscriptionList = new List <string>();
_fetchMarketData.InitializeDisruptor(new IEventHandler <MarketDataObject>[] { this });
_fetchMarketData.HistoricalDataFired += HistoricDataArrived;
}
catch (Exception exception)
{
_classLogger.Error(exception, _type.FullName, "DataHandler");
}
}
/// <summary>
/// Loads user strategy and extracts constructor parameters
/// </summary>
private void LoadUserStrategy(LoadStrategy loadStrategy)
{
try
{
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Trying to load user defined strategy from: " +
loadStrategy.StrategyAssembly.FullName.Substring(0, loadStrategy.StrategyAssembly.FullName.IndexOf(",", System.StringComparison.Ordinal)),
_type.FullName, "LoadUserStrategy");
}
var strategyDetails = LoadCustomStrategy.GetConstructorDetails(loadStrategy.StrategyAssembly);
if (strategyDetails != null)
{
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Successfully loaded custom strategy: " + strategyDetails.Item1.Name, _type.Name, "LoadUserStrategy");
}
// Create new Strategy Constructor Info object
StrategyConstructorInfo strategyConstructorInfo = new StrategyConstructorInfo(
strategyDetails.Item2, strategyDetails.Item1);
// Publish Event to Notify Listener.
EventSystem.Publish <StrategyConstructorInfo>(strategyConstructorInfo);
}
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "LoadUserStrategy");
}
}
/// <summary>
/// Connects/Starts a client
/// </summary>
public bool Start()
{
try
{
// Read account credentials
ReadConnectionParameters();
if (_connectionParameters == null)
{
_logger.Info("Connection Parameters unavailable", _type.FullName, "Start");
return(false);
}
// Send credential details to connection form
_connectionForm.Connect(_connectionParameters.LoginId, _connectionParameters.Password,
_connectionParameters.ProductId, _connectionParameters.ProductVersion);
Thread.Sleep(4000);
// Open connection with Data feed
_barData.OpenBarDataConnection();
_historicalData.OpenHistoricalDataConnection();
_levelOneData.OpenLevelOneDataConnection();
return(true);
}
catch (Exception exception)
{
_logger.Error(exception, _type.FullName, "Start");
}
return(false);
}
/// <summary>
/// Connects/Starts a client
/// </summary>
public bool Start()
{
try
{
// Read account credentials
ReadConnectionParameters();
if (_connectionParameters == null)
{
Logger.Info("Connection Parameters unavailable", _type.FullName, "Start");
return(false);
}
// Opens a new FXCM session
OpenSession();
return(true);
}
catch (Exception exception)
{
_logger.Error(exception, _type.FullName, "Start");
}
return(false);
}
/// <summary>
/// Called when new Tick message is received and processed by Disruptor
/// </summary>
/// <param name="message"></param>
private void OnTickDataReceived(string[] message)
{
try
{
Tick tick = new Tick();
// Parse incoming message to Tick
if (ParseToTick(tick, message))
{
// Notify Listeners
TickArrived(tick);
}
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "OnTickDataReceived");
}
}
/// <summary>
/// Constructor:
/// Loads Setting From Xml File
/// </summary>
/// <param name="readMarketData"></param>
/// <param name="classLogger"> </param>
public FetchData(ReadMarketData readMarketData, AsyncClassLogger classLogger)
{
try
{
_classLogger = classLogger;
_readMarketData = readMarketData;
//Reading Settings From Xml File
string path = "MarketDataConfiguration\\MarketDataController.xml";
XDocument doc;
if (File.Exists(path))
{
_classLogger.Info("1st", _type.FullName, "FetchData");
doc = XDocument.Load("MarketDataConfiguration\\MarketDataController.xml");
}
else
{
_classLogger.Info("2nd", _type.FullName, "FetchData");
doc = XDocument.Load("..\\Strategy Runner\\MarketDataConfiguration\\MarketDataController.xml");
}
var startDate = doc.Descendants("StartDate");
foreach (var xElement in startDate)
{
string[] start = xElement.Value.Split(',');
_startDate = new DateTime(Convert.ToInt32(start[0]), Convert.ToInt32(start[1]), Convert.ToInt32(start[2]));
if (_classLogger.IsInfoEnabled)
{
_classLogger.Info("StartDate:" + _startDate.ToString(CultureInfo.InvariantCulture), _type.FullName, "FetchData");
}
}
var endDate = doc.Descendants("EndDate");
foreach (var xElement in endDate)
{
string[] end = xElement.Value.Split(',');
_endDate = new DateTime(Convert.ToInt32(end[0]), Convert.ToInt32(end[1]), Convert.ToInt32(end[2]));
if (_classLogger.IsInfoEnabled)
{
_classLogger.Info("EndDate:" + _endDate.ToString(CultureInfo.InvariantCulture), _type.FullName, "FetchData");
}
}
var provider = doc.Descendants("Provider");
foreach (var xElement in provider)
{
_providerName = xElement.Value;
if (_classLogger.IsInfoEnabled)
{
_classLogger.Info("ProviderName:" + _providerName.ToString(CultureInfo.InvariantCulture), _type.FullName, "FetchData");
}
}
}
catch (Exception exception)
{
_classLogger.Error(exception, _type.FullName, "FetchData");
}
}
/// <summary>
/// Opens a connection to the IQFeed Connector
/// </summary>
public void OpenHistoricalDataConnection()
{
try
{
// Initialize IQFeed COM object
_historyLookupComObject = new DTNIQFeedCOMLib.HistoryLookup4();
// Hook necessary IQ Feed events
RegisterEvents();
// Use request to initiate the connection and set our IQFeed protocol here.
_historyLookupComObject.SetProtocol("5.2");
}
catch (Exception exception)
{
_logger.Error(exception, _type.FullName, "OpenBarDataConnection");
}
}
/// <summary>
/// Start Strategy Optimization
/// </summary>
/// <param name="optimizationParameters">Contains info for the parameters to be used for optimization</param>
private void StartOptimization(OptimizeStrategyBruteForce optimizationParameters)
{
try
{
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Getting argument combinations", _type.FullName, "StartOptimization");
}
// Clear all previous information
_strategiesCollection.Clear();
// Save Parameter Details
_parmatersDetails = optimizationParameters.ParmatersDetails;
// Get all ctor arguments to be used for optimization
CreateCtorCombinations(optimizationParameters.CtorArgs, optimizationParameters.ConditionalParameters);
// Initialize Stratgey for each set of arguments
foreach (object[] ctorArgument in _ctorArguments)
{
// Get new Key.
string key = ApplicationIdGenerator.NextId();
// Save Strategy details in new Strategy Executor object
StrategyExecutor strategyExecutor = new StrategyExecutor(key, optimizationParameters.StrategyType, ctorArgument);
// Register Event
strategyExecutor.StatusChanged += OnStrategyExecutorStatusChanged;
// Add to local map
_strategiesCollection.AddOrUpdate(key, strategyExecutor, (ky, value) => strategyExecutor);
}
// Start executing each instance
StartStrategyExecution();
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "StartOptimization");
}
}
/// <summary>
/// Handles the new incoming Server Heartbeat
/// </summary>
/// <param name="serverHeartbeatInterval">Time Interval after which MDE will send response Heartbeat</param>
public void Update(int serverHeartbeatInterval)
{
try
{
// Stop Timer for processing
StopValidationTimer();
if (_asyncClassLogger.IsDebugEnabled)
{
_asyncClassLogger.Debug("Server Heartbeat received", _type.FullName, "Update");
}
// Start Timer after processing
StartValidationTimer(serverHeartbeatInterval);
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "Update");
}
}
/// <summary>
/// Start Position Engine Service
/// </summary>
public bool StartService()
{
try
{
if (_isConnected)
{
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Position engine service already running.", _type.FullName, "StartService");
}
return(true);
}
// Start PE-Client
_positionEngineClient.Initialize();
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Position engine service started.", _type.FullName, "StartService");
}
return(true);
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "StartService");
return(false);
}
}
/// <summary>
/// Connects/Starts a client
/// </summary>
public bool Start()
{
try
{
// Read account credentials
_credentials = CredentialReader.ReadCredentials("RediParams.xml");
if (!CheckParameterValidity())
{
return(false);
}
// Create TCP Request
_rediSocketConnection = new SocketCommunication(new Queue(), _credentials.Username,
_credentials.Password, _credentials.IpAddress, Convert.ToInt32(_credentials.Port), _logger);
_rediSocketConnection.SendMessage += DataRecieved;
_rediSocketConnection.ErrorInTcp += new SocketCommunication.ConnectionError(RediSocketConnectionErrorInTcp);
_isConnected = true;
_rediSocketConnection.Connect();
if (_logger.IsInfoEnabled)
{
_logger.Info("Session is available.", _type.FullName, "Start");
}
if (LogonArrived != null)
{
LogonArrived(_marketDataProviderName);
}
return(true);
}
catch (Exception exception)
{
_logger.Error(exception, _type.FullName, "Start");
}
return(false);
}
/// <summary>
/// Subscribes Tick data for the given symbol
/// </summary>
/// <param name="subscribe">Contains info for the symbol to be subscribed</param>
public void SubscribeSymbol(Subscribe subscribe)
{
try
{
if (_classLogger.IsInfoEnabled)
{
_classLogger.Info("New subscription request received " + subscribe, _type.FullName, "SubscribeSymbol");
}
// Add new symbol to the Tick list
if (!TickSubscriptionList.Contains(subscribe.Security.Symbol))
{
TickSubscriptionList.Add(subscribe.Security.Symbol);
}
// Fetch data if its not already fetched for bars
if (!BarSubscriptionList.Contains(subscribe.Security.Symbol))
{
FetchData(subscribe);
}
}
catch (Exception exception)
{
_classLogger.Error(exception, _type.FullName, "SubscribeSymbol");
}
}
/// <summary>
/// Parse String into bar
/// </summary>
/// <param name="line"></param>
/// <param name="id"> </param>
/// <returns></returns>
private Bar ParseToBar(string line, string id)
{
try
{
string[] feilds = line.Split(',');
Bar newBar = new Bar(new Security {
Symbol = feilds[5]
}, Common.Core.Constants.MarketDataProvider.SimulatedExchange, id);
newBar.Close = Convert.ToDecimal(feilds[0]);
newBar.Open = Convert.ToDecimal(feilds[1]);
newBar.High = Convert.ToDecimal(feilds[2]);
newBar.Low = Convert.ToDecimal(feilds[3]);
newBar.Volume = (long)Convert.ToDouble(feilds[4]);
newBar.DateTime = DateTime.ParseExact(feilds[6], "M/d/yyyy h:mm:ss tt", CultureInfo.InvariantCulture);
return(newBar);
}
catch (Exception exception)
{
_classLogger.Error(exception, _type.FullName, "ParseToBar");
return(null);
}
}
/// <summary>
/// Subscribe symbols price updates
/// </summary>
/// <param name="symbol"></param>
public void Subscribe(string symbol)
{
if (_subscriptionList.Count == 0)
{
O2GTableManagerStatus managerStatus = _tableManager.getStatus();
while (managerStatus == O2GTableManagerStatus.TablesLoading)
{
Thread.Sleep(50);
managerStatus = _tableManager.getStatus();
}
if (managerStatus == O2GTableManagerStatus.TablesLoadFailed)
{
_logger.Error("Table loading failed", _type.FullName, "Subscribe");
return;
}
SubscribeEvents(_tableManager);
}
_subscriptionList.Add(symbol);
}
/// <summary>
/// Connects to Server.
/// </summary>
public void Connect()
{
_stopping = false;
if (_client != null)
{
throw new Exception("Connection already open!");
}
try
{
if (InitializeTcpClient())
{
var loginMessage = LogonMessage();
StartReaderThread();
_networkStream.Write(loginMessage, 0, loginMessage.Length);
_streamWriter.Flush();
}
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "Connect");
}
}
/// <summary>
/// Creates a FIX4.4 OrderCancelRequest message for Fxcm
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
public QuickFix.FIX44.OrderCancelRequest OrderCancelRequest(Order order)
{
char orderSide = default(char);
if (order.OrderSide == Constants.OrderSide.BUY)
{
orderSide = Side.BUY;
}
else if (order.OrderSide == Constants.OrderSide.SELL)
{
orderSide = Side.SELL;
}
if (orderSide.Equals(default(char)))
{
_logger.Error("Invalid Order Side", _type.FullName, "OrderCancelRequest");
return(null);
}
QuickFix.FIX44.OrderCancelRequest orderCancelRequest = new QuickFix.FIX44.OrderCancelRequest();
QuickFix.Fields.OrderID orderId = new QuickFix.Fields.OrderID(order.BrokerOrderID);
orderCancelRequest.SetField(orderId);
QuickFix.Fields.OrigClOrdID origClOrdId = new QuickFix.Fields.OrigClOrdID(order.OrderID);
orderCancelRequest.SetField(origClOrdId);
QuickFix.Fields.ClOrdID clOrdId = new QuickFix.Fields.ClOrdID(DateTime.Now.ToString(("yyMMddHmsfff")));
orderCancelRequest.SetField(clOrdId);
var account = new QuickFix.Fields.Account(_account);
orderCancelRequest.SetField(account);
QuickFix.Fields.Symbol symbol = new QuickFix.Fields.Symbol(order.Security.Symbol);
orderCancelRequest.SetField(symbol);
QuickFix.Fields.Side side = new QuickFix.Fields.Side(orderSide);
orderCancelRequest.SetField(side);
QuickFix.Fields.TransactTime transactTime = new QuickFix.Fields.TransactTime(order.OrderDateTime);
orderCancelRequest.SetField(transactTime);
QuickFix.Fields.Product product = new QuickFix.Fields.Product(FixCommon.Constants.Product.Currency);
orderCancelRequest.SetField(product);
return(orderCancelRequest);
}
/// <summary>
/// Subscribes Tick data for the given symbol
/// </summary>
/// <param name="subscribe">Contains info for the symbol to be subscribed</param>
public void SubscribeSymbol(Subscribe subscribe)
{
try
{
if (_classLogger.IsInfoEnabled)
{
_classLogger.Info("New subscription request received " + subscribe, _type.FullName,
"SubscribeSymbol");
}
// Add new symbol to the Tick list
if (!TickSubscriptionList.Contains(subscribe.Security.Symbol))
{
TickSubscriptionList.Add(subscribe.Security.Symbol);
}
// Fetch data if its not already fetched for bars
if (!BarSubscriptionList.Contains(subscribe.Security.Symbol))
{
// Use locally saved data
if (_persistanceDataCount > 0)
{
var task = Task.Factory.StartNew(UseLocalData);
_tasksCollection.Add(task);
}
// Fetch fresh data
else
{
FetchData(subscribe);
}
}
}
catch (Exception exception)
{
_classLogger.Error(exception, _type.FullName, "SubscribeSymbol");
}
}
/// <summary>
/// Argument Constructor
/// </summary>
/// <param name="classLogger"></param>
public ReadMarketData(AsyncClassLogger classLogger)
{
try
{
_classLogger = classLogger;
// The folder for the roaming current user
string folder = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
// Combine the base folder with your specific folder....
_specificFolder = Path.Combine(folder, "DataDownloader");
// Check if folder exists and if not, create it
if (!Directory.Exists(_specificFolder))
{
Directory.CreateDirectory(_specificFolder);
}
}
catch (Exception exception)
{
_classLogger.Error(exception, _type.FullName, "ReadMarketData");
}
}
/// <summary>
/// Execute Strategy iteration to calculate Fitness
/// </summary>
/// <returns>Return Strategy's Fitness for current execution</returns>
public double ExecuteStrategy(double[] values)
{
try
{
_manualReset = new ManualResetEvent(false);
//convert all parameters to object.
object[] array = new object[values.Length];
for (int i = 0; i < values.Length; i++)
{
array[i] = values[i];
}
// Update Strategy Parameters
_tradeHubStrategy.SetParameters(array);
// Reset Statistics for current iteration
_statistics.ResetAllValues();
_orderExecutor.Clear();
// Start Strategy Execution
_tradeHubStrategy.Run();
// Wait for the strategy to execute
_manualReset.WaitOne();
// Clear subscription maps
_dataHandler.ClearMaps();
_tradeHubStrategy.ClearOrderMap();
// return current iterations risk
return(-1 * (double)_tradeHubStrategy.GetObjectiveFunctionValue());
}
catch (Exception exception)
{
_logger.Error(exception, _type.FullName, "ExecuteStrategy");
return(default(double));
}
}
/// <summary>
/// Starts Order Execution Service
/// </summary>
public bool StartService()
{
try
{
if (_isConnected)
{
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Order execution service already running.", _type.FullName, "StartService");
}
return(true);
}
// Start OEE-Client
_executionEngineClient.Start();
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Order Execution service started.", _type.FullName, "StartService");
}
return(true);
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "StartService");
return(false);
}
}
/// <summary>
/// Timer expired
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TimerExpired(object sender, ElapsedEventArgs e)
{
foreach (var order in _ordersMap.Values.ToArray())
{
try
{
var orderStatus = _tradierManager.GetOrderStatus(order.BrokerOrderID);
if (_logger.IsInfoEnabled)
{
_logger.Info(orderStatus.order.ToString(), _type.FullName, "TimerExpired");
}
if (orderStatus.order.status.Equals("filled", StringComparison.InvariantCultureIgnoreCase))
{
Fill fill = new Fill(new Security()
{
Symbol = order.Security.Symbol
},
order.OrderExecutionProvider, order.OrderID);
fill.ExecutionId = Guid.NewGuid().ToString();
fill.ExecutionType = ExecutionType.Fill;
fill.LeavesQuantity = orderStatus.order.remaining_quantity;
fill.CummalativeQuantity = orderStatus.order.exec_quantity;
fill.ExecutionSize = orderStatus.order.last_fill_quantity;
fill.AverageExecutionPrice = orderStatus.order.avg_fill_price;
fill.ExecutionPrice = orderStatus.order.last_fill_price;
DateTime executionDateTime;
if (!DateTime.TryParse(orderStatus.order.transaction_date, out executionDateTime))
{
executionDateTime = DateTime.UtcNow;
}
fill.ExecutionDateTime = executionDateTime;
fill.ExecutionSide = order.OrderSide;
order.OrderStatus = OrderStatus.EXECUTED;
Order orderClone = (Order)order.Clone();
Execution execution = new Execution(fill, orderClone);
execution.OrderExecutionProvider = _provider;
if (ExecutionArrived != null)
{
ExecutionArrived(execution);
}
Order deleteOrder;
//remove order from the map
_ordersMap.TryRemove(order.OrderID, out deleteOrder);
}
else if (orderStatus.order.status.Equals("partially_filled", StringComparison.InvariantCultureIgnoreCase) && order.OrderStatus != OrderStatus.PARTIALLY_EXECUTED)
{
Fill fill = new Fill(new Security()
{
Symbol = order.Security.Symbol
},
order.OrderExecutionProvider, order.OrderID);
fill.ExecutionId = Guid.NewGuid().ToString();
fill.ExecutionType = ExecutionType.Partial;
fill.LeavesQuantity = orderStatus.order.remaining_quantity;
fill.CummalativeQuantity = orderStatus.order.exec_quantity;
fill.ExecutionSize = orderStatus.order.last_fill_quantity;
fill.AverageExecutionPrice = orderStatus.order.avg_fill_price;
fill.ExecutionPrice = orderStatus.order.last_fill_price;
DateTime executionDateTime;
if (!DateTime.TryParse(orderStatus.order.transaction_date, out executionDateTime))
{
executionDateTime = DateTime.UtcNow;
}
fill.ExecutionDateTime = executionDateTime;
fill.ExecutionSide = order.OrderSide;
order.OrderStatus = OrderStatus.PARTIALLY_EXECUTED;
Order orderClone = (Order)order.Clone();
Execution execution = new Execution(fill, orderClone);
execution.OrderExecutionProvider = _provider;
if (ExecutionArrived != null)
{
ExecutionArrived(execution);
}
}
else if (orderStatus.order.status == "submitted" && order.OrderStatus != OrderStatus.SUBMITTED)
{
order.OrderStatus = OrderStatus.SUBMITTED;
if (NewArrived != null)
{
NewArrived((Order)order.Clone());
}
}
else if (orderStatus.order.status == "rejected")
{
if (OrderRejectionArrived != null)
{
OrderRejectionArrived(new Rejection(order.Security, _provider)
{
OrderId = order.OrderID
});
}
Order deleteOrder;
//remove order from the map
_ordersMap.TryRemove(order.OrderID, out deleteOrder);
}
}
catch (Exception exception)
{
_logger.Error(exception, _type.FullName, "TimerExpired");
}
}
}
/// <summary>
/// Start Strategy Optimization
/// </summary>
/// <param name="optimizationParameters">Contains info for the parameters to be used for optimization</param>
private void StartOptimization(BruteForceParameters optimizationParameters)
{
try
{
// Save instance
_optimizationParameters = optimizationParameters;
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Getting argument combinations", _type.FullName, "StartOptimization");
}
// Change Status to indicate on UI
_optimizationParameters.Status = OptimizationStatus.Working;
// Clear all previous information
_strategiesCollection.Clear();
_ctorArguments.Clear();
// Get Parameter values to be used in the Constructor
object[] ctorArguments = optimizationParameters.GetParameterValues();
// Get Conditional Parameter values to be used for creating Iterations
Tuple <int, object, double>[] conditionalParameters = optimizationParameters.GetConditionalParameters();
// Save Parameter Details
_parmatersDetails = optimizationParameters.ParameterDetails;
// Get all ctor arguments to be used for optimization
CreateCtorCombinations(ctorArguments, conditionalParameters);
// Initialize Stratgey for each set of arguments
foreach (object[] ctorArgumentValues in _ctorArguments)
{
// Get new Key.
string key = ApplicationIdGenerator.NextId();
var instanceParameterDetails = new Dictionary <string, ParameterDetail>();
for (int i = 0; i < ctorArgumentValues.Length; i++)
{
// Create new parameter details to be when creating Strategy Instance object
ParameterDetail tempParameterDetail = new ParameterDetail(_parmatersDetails[i].ParameterType, ctorArgumentValues[i]);
instanceParameterDetails.Add(_parmatersDetails[i].Description, tempParameterDetail);
}
// Create Strategy Instance object
var instance = new StrategyInstance(key, instanceParameterDetails, optimizationParameters.StrategyType);
// Save Strategy details in new Strategy Executor object
var strategyExecutor = new StrategyExecutor(instance, _currentDispatcher);
// Register Event
strategyExecutor.StatusChanged += OnStrategyExecutorStatusChanged;
// Add to local map
_strategiesCollection.AddOrUpdate(key, strategyExecutor, (ky, value) => strategyExecutor);
StringBuilder parametersInfo = new StringBuilder();
foreach (object ctorArgument in strategyExecutor.CtorArguments)
{
parametersInfo.Append(ctorArgument.ToString());
parametersInfo.Append(" | ");
}
// Create new object to be used with Event Aggregator
var optimizationStatistics = new OptimizationStatistics(strategyExecutor.StrategyKey);
optimizationStatistics.Description = parametersInfo.ToString();
optimizationStatistics.ExecutionDetails = instance.ExecutionDetails;
// Raise event to Bind statistics to UI and will be updated as each instance is executed
EventSystem.Publish <OptimizationStatistics>(optimizationStatistics);
}
// Save total number of iterations count
_optimizationParameters.TotalIterations = _strategiesCollection.Count;
// Start executing each instance
StartStrategyExecution();
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "StartOptimization");
}
}
/// <summary>
/// Called when new limit order is recieved
/// </summary>
/// <param name="limitOrder">TradeHub LimitOrder</param>
public void NewLimitOrderArrived(LimitOrder limitOrder)
{
try
{
if (ValideLimitOrder(limitOrder))
{
var order = new Order(limitOrder.OrderID,
limitOrder.OrderSide,
limitOrder.OrderSize,
limitOrder.OrderTif,
limitOrder.OrderCurrency,
limitOrder.Security,
limitOrder.OrderExecutionProvider);
//change order status to open
order.OrderStatus = OrderStatus.OPEN;
order.StrategyId = limitOrder.StrategyId;
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("New Arrived :" + order, _type.FullName, "NewLimitOrderArrived");
}
// get index
int index;
int.TryParse(limitOrder.Remarks.Split('-')[1], out index);
//add limit order to list
_limitOrders.Add(index, limitOrder);
if (NewOrderArrived != null)
{
NewOrderArrived(order);
}
//Tick tick=new Tick();
//tick.LastPrice = _lastTradePrice;
//tick.LastSize = _lastTradeSize;
//tick.DateTime = _lastdateTime;
//tick.Security = new Security() {Symbol = limitOrder.Security.Symbol};
//ExecuteLimitOrder(limitOrder,_latestBar);
}
else
{
Rejection rejection = new Rejection(limitOrder.Security, OrderExecutionProvider.SimulatedExchange)
{
OrderId = limitOrder.OrderID, DateTime = DateTime.Now, RejectioReason = "Invaild Price Or Size"
};
limitOrder.OrderStatus = OrderStatus.REJECTED;
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Rejection :" + rejection, _type.FullName, "NewLimitOrderArrived");
}
if (RejectionArrived != null)
{
RejectionArrived.Invoke(rejection);
}
}
//if (_orderRepository != null)
//{
// _orderRepository.AddUpdate(limitOrder);
//}
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "NewLimitOrderArrived");
}
}
/// <summary>
/// Connects/Starts a client
/// </summary>
public bool Start()
{
try
{
// Read account credentials
_credentials = CredentialReader.ReadCredentials("TradierParams.xml");
if (String.IsNullOrEmpty(_credentials.ApiUrl) || String.IsNullOrWhiteSpace(_credentials.ApiUrl))
{
return(false);
}
// Create HTTP Request
var client = new RestClient(_credentials.ApiUrl + "/user/profile");
var request = new RestRequest(Method.GET);
request.AddHeader("authorization", "Bearer " + _credentials.AccessToken);
request.AddHeader("accept", "application/json");
// Send Request
IRestResponse response = client.Execute(request);
var requestResult = JsonConvert.DeserializeObject <dynamic>(response.Content);
string profileId = requestResult.profile.id.ToString();
if (!String.IsNullOrEmpty(profileId))
{
_isConnected = true;
// Start process to consume quotes
StartDataConsumer();
if (Logger.IsInfoEnabled)
{
Logger.Info("Session is available.", _type.FullName, "Start");
}
if (LogonArrived != null)
{
LogonArrived(_marketDataProviderName);
}
return(_isConnected);
}
// Get error message
string faultstring = requestResult.fault.faultstring.ToString();
if (Logger.IsInfoEnabled)
{
Logger.Info("Session not available " + faultstring, _type.FullName, "Start");
}
return(_isConnected);
}
catch (Exception exception)
{
_logger.Error(exception, _type.FullName, "Start");
}
return(false);
}