public static void UpdateProfitLoss(SimpleLogger log, SignalFile signalFile, string pnl)
{
try
{
var sqlite_conn = CreateConnection();
int result = 0;
var sql1 = $"REPLACE INTO profit_Loss VALUES ('{ signalFile.TradeDate}', '{signalFile.TradeDateTime}', '{signalFile.StrategyName}', '{pnl}'); ";
using (SQLiteCommand sqlite_cmd1 = new SQLiteCommand(sql1, sqlite_conn))
{
sqlite_cmd1.CommandText = sql1;
result = sqlite_cmd1.ExecuteNonQuery();
}
if (result > 0)
{
log.Db("Successfully updated profit_Loss table.");
}
else
{
log.Db("Failed to update profit_Loss table.");
}
sqlite_conn.Close();
}
catch (SQLiteException ex)
{
log.Trace("Error " + ex.Message.ToString());
}
}
public static void LoadPositions(Strategy strategy, Positions positions, SimpleLogger log)
{
foreach (string line in Positions.PositionList)
{
string symbol = SignalFile.GetWantedText(line, "Symbol:");
if (strategy.Symbol == symbol)
{
positions.IBSymbol = strategy.Symbol;
string pos = SignalFile.GetWantedText(line, "Position:");
positions.IBCurrentPosition = Convert.ToInt32(pos);
break;
}
}
if (string.IsNullOrEmpty(positions.IBSymbol))
{
int strategyPosition = 0;//DBFunctions.GetCurrentStrategyPositionFromDB(log, strategy);
Positions.SetIBPosition(strategy, strategyPosition, positions);
log.Broker($"IB Position does not exist. Setting position for symbol: {strategy.Symbol}, position: {strategyPosition}");
//log.Broker($"Using curr_Strategy_Position table for Positions Update. symbol: {strategy.Symbol}, position: {strategyPosition}");
}
}
private void ValidateParsedDataForTrade(SignalFile signalFile)
{
const int _max = 1000000;
Stopwatch s1 = Stopwatch.StartNew();
DateTime tradeDateTime = Convert.ToDateTime(string.Format("{0:MM-dd-yyyy}", signalFile.TradeDateTime.Trim()), CultureInfo.CurrentCulture);
string entryDateTime = tradeDateTime.ToString("MM-dd-yyyy");
if (signalFile.TradeDate == DateToday.Today && entryDateTime == DateToday.Today)
{
//Map TS symbol to IB symbol and set contract details
FuturesContract futuresContract = new FuturesContract();
futuresContract = futures.GetContractDetails(contract, futuresContract, signalFile);
//Map TS strategies to strategies defined in application data list
Strategy strategy = new Strategy(log);
Strategy.GetStrategyId(futuresContract, strategy, signalFile, log);
if (InitializeValues(strategy, signalFile))
{
//Check if app is connected to IB Api and get current IB positions
Positions positions = new Positions();
broker.UpdateIBpositions(strategy, positions, log);
//Check last position for strategy in Position_Data table
Transactions transactions = new Transactions();
Transactions.CheckLastPositionDataFromDB(transactions, strategy, signalFile, log);
//Check if strategy has exceeded maximum position
//Tuple MaxTradeFlag, dbPosConflict, strategyCurrentPosition
Tuple <bool, bool, int> db = positions.GetMaxPosition(strategy, signalFile, transactions, positions, log, @params);
//Display transaction conflict message
Transactions.CheckLastTrade(signalFile, transactions, log, positions, db);
//Set lot size based on current IB position
OrderDetails orderDetails = new OrderDetails();
orderDetails = OrderDetails.GetLotSize(db, orderDetails, strategy, signalFile, positions);
//Check if a limit order was never filled at the Broker and cancel any open order(s)
//Tuple MaxTradeFlag, dbPosConflict, strategyCurrentPosition
if (db.Item2) //db.Item1 ||
{
bool allOpenOrder = false;
CancelOpenOrders(strategy, db.Item2, orderDetails, allOpenOrder);
}
//If trade is for today and less than max position excute order
ProcessSignalForTrade(futuresContract, signalFile, orderDetails, strategy, db, log);
}
}
s1.Stop();
string diag = string.Format("Processed Order in: " + (s1.Elapsed.TotalMilliseconds * 1000000 / _max).ToString("0.00 ns"));
log.Info(diag);
}
private void UpdateDBTables(FuturesContract futuresContract, SignalFile signalFile, OrderDetails orderDetails, Strategy strategy, double limitPrice)
{
int currentPositionForDB = GetCurrentPositionForDB(orderDetails, strategy);
DBFunctions.UpdatePositionDataToDb(log, futuresContract, signalFile, orderDetails, limitPrice);
DBFunctions.UpdateStrategyPosition(log, currentPositionForDB, strategy, orderDetails);
DBFunctions.CalculateProfitandLoss(log, strategy, signalFile);
}
private static OrderDetails GetOrderSide(SignalFile signalFile, OrderDetails orderDetails)
{
if (signalFile.Signal == -1)
{
orderDetails.SideText = "SHORT";
orderDetails.BuyOrSell = "SELL";
}
else
{
orderDetails.SideText = "LONG";
orderDetails.BuyOrSell = "BUY";
}
return(orderDetails);
}
private double GetPrices(FuturesContract futuresContract, SignalFile signalFile, Strategy strategy, OrderDetails orderDetails, Prices prices, Tuple <bool, bool, int> db)
{
double limitPrice = 0;
if (prices.BidPrice > 0 && prices.AskPrice > 0)
{
limitPrice = GetBrokerLimitPrice(futuresContract, orderDetails, prices, strategy, db, signalFile);
}
else if (limitPrice <= 0)
{
limitPrice = GetSignalFileLimitPrice(futuresContract, orderDetails, signalFile, strategy, db);
}
return(limitPrice);
}
public static void CheckLastTrade(SignalFile signalFile, Transactions transactions, SimpleLogger log, Positions positions, Tuple <bool, bool, int> db)
{
if (db.Item1)
{
log.Warning($"Trying to Exceed Max Position. No order sent for {signalFile.Output}");
}
if (signalFile.Signal == 1 && transactions.LastTradeSide == 1 && positions.IBCurrentPosition > 0 && signalFile.StrategyName == transactions.Strategy)
{
log.Warning($"Last order sent in db was a BUY for {signalFile.Output}");
}
if (signalFile.Signal == -1 && transactions.LastTradeSide == -1 && positions.IBCurrentPosition < 0 && signalFile.StrategyName == transactions.Strategy)
{
log.Warning($"Last order sent in db was a SELL for {signalFile.Output}");
}
}
public double GetProfitTicks(Strategy strategy, SignalFile signalFile)
{
double profitTicks = 0;
if (strategy.Symbol == "QM")
{
if (signalFile.Adx < 15)
{
profitTicks = .35;
return(profitTicks);
}
else
{
profitTicks = 1.00;
return(profitTicks);
}
}
else if (strategy.Symbol == "MES")
{
if (signalFile.Adx < 15)
{
profitTicks = @params.@sp500ProfitOne;
return(profitTicks);
}
else
{
profitTicks = @params.@sp500ProfitTwo;
return(profitTicks);
}
}
else if (strategy.Symbol == "MGC")
{
if (signalFile.Adx < 15)
{
profitTicks = 5.00;
return(profitTicks);
}
else
{
profitTicks = 15.00;
return(profitTicks);
}
}
return(profitTicks);
}
public Tuple <bool, int> ComparePositionAtIBandDB(Strategy strategy, SignalFile signalFile, Positions positions, SimpleLogger log, Parameters @params)
{
bool dbPosConflict = false;
int dbPosition = DBFunctions.GetCurrentStrategyPositionFromDB(log, strategy);
if (dbPosition != positions.IBCurrentPosition && signalFile.StrategyName == strategy.StrategyName)
{
string slackMsg = $"*[POSITION CONFLICT]* *{strategy.StrategyName}* curr_Strategy_Position table:*{dbPosition}* and IB:*{IBCurrentPosition}*";
dbPosConflict = true;
log.Warning(slackMsg);
slack.SendMessageToSlack(slackMsg, @params);
}
return(new Tuple <bool, int>(dbPosConflict, dbPosition));
}
private double CalculateMaxPosition(double position, Strategy strategy, SignalFile signalFile, Transactions transactions, SimpleLogger log)
{
double calculatedMaxPosition = 0;
if (signalFile.Signal == transactions.LastTradeSide)
{
calculatedMaxPosition = (position + strategy.StrategyMaxPosition);
}
else if (signalFile.Signal != transactions.LastTradeSide)
{
calculatedMaxPosition = (strategy.StrategyMaxPosition - position);
}
else if (transactions.LastTradeSide == 0)
{
calculatedMaxPosition = (strategy.StrategyMaxPosition - position);
}
log.Warning($"signalFile.Signal:{signalFile.Signal} transactions.LastTradeSide:{transactions.LastTradeSide} position:{position} strategy.StrategyMaxPosition:{strategy.StrategyMaxPosition} calculatedMaxPosition:{calculatedMaxPosition}");
return(calculatedMaxPosition);
}
private void ProcessSignalForTrade(FuturesContract futuresContract, SignalFile signalFile, OrderDetails orderDetails, Strategy strategy, Tuple <bool, bool, int> db, SimpleLogger log)
{
if (!db.Item1 && [email protected])
{
slack.SendMessageToSlack($"[*{strategy.Symbol} {orderDetails.BuyOrSell}]*\n*{signalFile.LastFileLine}*", @params);
//Cancel any open orders
bool dbconflict = false;
bool allOpenOrder = true;
CancelOpenOrders(strategy, dbconflict, orderDetails, allOpenOrder);
//Send order to Broker
double limitPrice = ExecuteOrder(futuresContract, signalFile, orderDetails, strategy, log, db);
//Used to check order status @ Broker
//CheckOrderStatus();
//Update db with executed strategy order
UpdateDBTables(futuresContract, signalFile, orderDetails, strategy, limitPrice);
}
}
private bool InitializeValues(Strategy strategy, SignalFile signalFile)
{
if (strategy.Symbol == "QM" && strategy.Status) //@params.crudeEnabled)
{
return(true);
}
if (strategy.Symbol == "MES" && strategy.Status) //@params.sp500Enabled)
{
return(true);
}
if (strategy.Symbol == "MGC" && strategy.Status) //@params.goldEnabled)
{
return(true);
}
log.Warning($"{strategy.StrategyName} is disabled.");
string side = (signalFile.Signal == 1) ? "BUY" : "SELL";
slack.SendMessageToSlack($"[*{strategy.StrategyName} {side}. Disabled]*\n*{signalFile.LastFileLine}*", @params);
return(false);
}
private string OverNight(SignalFile signalFile, Tuple <bool, bool, int> db)
{
string orderType = null;
TimeSpan time = DateTime.Now.TimeOfDay;
if (db.Item3 != 0)
{
if (time > new TimeSpan(00, 00, 00) && time < new TimeSpan(08, 00, 00)) //Hours, Minutes, Seconds
{
orderType = "MKT";
}
else if (time > new TimeSpan(22, 00, 00) && time < new TimeSpan(23, 59, 59))
{
orderType = "MKT";
}
//else if (time > new TimeSpan(18, 00, 00) && time < new TimeSpan(23, 59, 59))
//{
// orderType = "MKT";
//}
}
return(orderType);
}
public static OrderDetails GetLotSize(Tuple <bool, bool, int> db, OrderDetails orderDetails, Strategy strategy, SignalFile signalFile, Positions positions)
{
int signalDirection = signalFile.Signal;
//int tradeDirection;
int strategyCurrentPosition = db.Item3;
//Trade direction
//if (strategyCurrentPosition > 0 && signalDirection < 0)
//{
// tradeDirection = -1;
//}
//else if (strategyCurrentPosition < 0 && signalDirection > 0)
//{
// tradeDirection = 1;
//}
//else if (strategyCurrentPosition < 0 && signalDirection < 0)
//{
// tradeDirection = -1;
//}
//else if (strategyCurrentPosition > 0 && signalDirection > 0)
//{
// tradeDirection = 1;
//}
//else
//{
// tradeDirection = signalFile.Signal;
//}
if (positions.IBSymbol == strategy.Symbol && signalFile.StrategyName == strategy.StrategyName)
{
switch (signalFile.Exit)
{
case "0":
if (strategyCurrentPosition > 0 && strategyCurrentPosition != 0 && signalDirection < 0)
{
orderDetails.LotSize = (strategy.LotSize * 2);
}
else if (strategyCurrentPosition < 0 && strategyCurrentPosition != 0 && signalDirection > 0)
{
orderDetails.LotSize = (strategy.LotSize * 2);
}
else if (strategyCurrentPosition != 0)
{
orderDetails.LotSize = strategy.LotSize;
}
else
{
orderDetails.LotSize = strategy.LotSize;
}
break;
case "1":
//if (strategyCurrentPosition > 0 && signalDirection != tradeDirection)
//{
// orderDetails.LotSize = strategy.LotSize;
//}
//else if (strategyCurrentPosition < 0 && signalDirection != tradeDirection)
//{
// orderDetails.LotSize = strategy.LotSize;
//}
//else
//{
orderDetails.LotSize = strategy.LotSize;
//}
break;
}
}
else if (string.IsNullOrEmpty(positions.IBSymbol) && strategyCurrentPosition == 0)
{
orderDetails.LotSize = strategy.LotSize;
}
GetOrderSide(signalFile, orderDetails);
return(orderDetails);
}
private void MonitorSignalFile()
{
long initialFileSize = new FileInfo(@params.filePath).Length;
long lastReadLength = initialFileSize - 1024;
if (lastReadLength < 0)
{
lastReadLength = 0;
}
while (true)
{
try
{
long fileSize = new FileInfo(@params.filePath).Length;
TimeSpan time = DateTime.Now.TimeOfDay;
if (time > new TimeSpan(00, 50, 00) && time < new TimeSpan(00, 50, 15)) //Hours, Minutes, Seconds
{
break;
}
if (fileSize > lastReadLength)
{
using (FileStream fs = new FileStream(@params.filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
fs.Seek(lastReadLength, SeekOrigin.Begin);
byte[] buffer = new byte[1024];
while (true)
{
DateToday.Today = DateTime.Today.ToString("MM-dd-yyyy");
int bytesRead = fs.Read(buffer, 0, buffer.Length);
lastReadLength += bytesRead;
if (bytesRead == 0)
{
break;
}
string[] lines;
List <string> list = new List <string>();
FileStream fileStream = new FileStream(@params.filePath, FileMode.Open, FileAccess.Read);
using (StreamReader streamReader = new StreamReader(fileStream, Encoding.UTF8))
{
string line;
while ((line = streamReader.ReadLine()) != null)
{
list.Add(line);
}
}
SignalFile signalFile = new SignalFile();
lines = list.ToArray();
signalFile.LastFileLine = lines.Last().ToString();
log.Signal($"[RAW DATA] {signalFile.LastFileLine}");
//Parse signal file data for trade validation
signalFile = SignalFile.ParseSignalFile(signalFile, log);
//Validate signal and process order if valid
ValidateParsedDataForTrade(signalFile);
}
}
}
}
catch (Exception ex)
{
log.Trace(ex.Message.ToString());
log.Trace(ex.StackTrace.ToString());
}
Thread.Sleep(TimeSpan.FromSeconds(2));
}
//Restart App after IB Trader Workstation does its daily restart
broker.RestartProgram();
}
public Tuple <bool, bool, int> GetMaxPosition(Strategy strategy, SignalFile signalFile, Transactions transactions, Positions positions, SimpleLogger log, Parameters @params)
{
bool MaxTradeFlag = true;
bool maxPosFlag;
double _position;
Tuple <bool, int> db = ComparePositionAtIBandDB(strategy, signalFile, positions, log, @params);
bool dbPosConflict = db.Item1;
int strategyCurrentPosition = db.Item2;
double calculatedMaxPosition;
//Converting position to positive number to validate if the number exceeds the max number for the strategy maximum position(s)
if (!dbPosConflict)
{
_position = (strategyCurrentPosition < 0) ? -1 * strategyCurrentPosition : strategyCurrentPosition;
calculatedMaxPosition = CalculateMaxPosition(_position, strategy, signalFile, transactions, log);
}
else
{
_position = (positions.IBCurrentPosition < 0) ? -1 * positions.IBCurrentPosition : positions.IBCurrentPosition;
if (dbPosConflict)//if dbconflict then the position in the database must be incorrect and last trade was never filled
{
if (positions.IBCurrentPosition > 0)
{
transactions.LastTradeSide = 1;
}
else if (positions.IBCurrentPosition < 0)
{
transactions.LastTradeSide = -1;
}
strategyCurrentPosition = positions.IBCurrentPosition;
log.Warning($"Positions conflict. Using IB Position for last trade side: {transactions.LastTradeSide}");
}
calculatedMaxPosition = CalculateMaxPosition(_position, strategy, signalFile, transactions, log);
}
if (calculatedMaxPosition > strategy.StrategyMaxPosition && calculatedMaxPosition >= strategy.MaxPositionForSymbol)
{
maxPosFlag = true;
log.Warning($"{signalFile.StrategyName} is trying to Exceed Strategy Max Position of {strategy.StrategyMaxPosition}.");
}
else if (calculatedMaxPosition <= strategy.StrategyMaxPosition)
{
maxPosFlag = false;
}
else
{
maxPosFlag = false;
}
log.Warning($"{signalFile.StrategyName} dbPosConflict:{dbPosConflict} MaxTradeFlag:{MaxTradeFlag} calculatedMaxPosition:{calculatedMaxPosition} strategy.StrategyMaxPosition:{strategy.StrategyMaxPosition} strategy.MaxPositionForSymbol:{strategy.MaxPositionForSymbol}");
if (signalFile.StrategyName == strategy.StrategyName && !maxPosFlag && strategyCurrentPosition != 0)
{
switch (signalFile.Signal)
{
case 1:
if (strategyCurrentPosition < 0)
{
MaxTradeFlag = false;
}
else if (strategyCurrentPosition > 0 && _position <= strategy.MaxPositionForSymbol)
{
MaxTradeFlag = false;
}
break;
case -1:
if (strategyCurrentPosition > 0)
{
MaxTradeFlag = false;
}
else if (strategyCurrentPosition < 0 && _position <= strategy.MaxPositionForSymbol)
{
MaxTradeFlag = false;
}
break;
}
}
else if (strategyCurrentPosition == 0)
{
MaxTradeFlag = false;
}
return(new Tuple <bool, bool, int>(MaxTradeFlag, dbPosConflict, strategyCurrentPosition));
}
private bool CancelOpenOrders(Strategy strategy, bool dbconflict, OrderDetails orderDetails, bool allOpenOrder)
{
bool openOrderstatus = false;
OpenOrder.OpenOrderFlag = false;
int cnt = 0;
if (strategy.OrderType == "LMT")
{
OpenOrder.OpenOrderList.DataList.Clear();
clientSocket.reqAllOpenOrders();
while (!OpenOrder.OpenOrderFlag)
{
if (OpenOrder.OpenOrderFlag)
{
break;
}
if (cnt > @params.maxLoopCount)
{
log.Warning("[IB WARNING] Could not update IB Open Order.");
break;
}
log.Warning($"Waiting for IB Open Order to Update. Try # {cnt}");
cnt++;
}
List <int> cancelList = new List <int>();
foreach (string openOrder in OpenOrder.OpenOrderList.DataList)
{
OpenOrder.Symbol = SignalFile.GetWantedText(openOrder, "Symbol:");
OpenOrder.OrderId = SignalFile.GetWantedText(openOrder, "Id:");
OpenOrder.OrderState = SignalFile.GetWantedText(openOrder, "OrderState:");
OpenOrder.Action = SignalFile.GetWantedText(openOrder, "Action:");
if (allOpenOrder && OpenOrder.Symbol == strategy.Symbol && OpenOrder.OrderState.Contains("Submit"))
{
int id = Convert.ToInt32(OpenOrder.OrderId);
cancelList.Add(id);
}
else if (dbconflict && OpenOrder.Action == orderDetails.BuyOrSell && OpenOrder.Symbol == strategy.Symbol && OpenOrder.OrderState.Contains("Submit"))
{
int id = Convert.ToInt32(OpenOrder.OrderId);
cancelList.Add(id);
}
else if (!dbconflict && OpenOrder.Symbol == strategy.Symbol && OpenOrder.OrderState.Contains("Submit"))
{
int id = Convert.ToInt32(OpenOrder.OrderId);
cancelList.Add(id);
}
}
if (cancelList.Count() > 0)
{
foreach (int id in cancelList)
{
clientSocket.cancelOrder(id);
log.Warning($"Cancelling open order for {strategy.StrategyName} OrderId: {id}.");
openOrderstatus = true;
}
}
}
return(openOrderstatus);
}
public static void UpdatePositionDataToDb(SimpleLogger log, FuturesContract futuresContract, SignalFile signalFile, OrderDetails orderDetails, double limitPrice)
{
try
{
var sqlite_conn = CreateConnection();
SQLiteCommand sqlite_cmd;
sqlite_cmd = sqlite_conn.CreateCommand();
sqlite_cmd.CommandText = "INSERT INTO Position_Data" +
" VALUES ( '" + signalFile.TradeDate +
"','" + signalFile.TradeDateTime +
"','" + orderDetails.OrderId +
"','" + signalFile.StrategyName +
"','" + futuresContract.Exchange +
"','" + orderDetails.BuyOrSell +
"','" + orderDetails.OrderStatus +
"'," + limitPrice.ToString("0." + new string('#', 20)) +
");";
int result = sqlite_cmd.ExecuteNonQuery();
if (result > 0)
{
log.Db("Successfully updated Position_Data table.");
}
else
{
log.Db("Failed to update Position_Data table.");
}
sqlite_conn.Close();
}
catch (SQLiteException ex)
{
log.Trace("Error " + ex.Message.ToString());
log.Trace(ex.StackTrace.ToString());
}
}
public static void CalculateProfitandLoss(SimpleLogger log, Strategy strategy, SignalFile signalFile)
{
var sqlite_conn = CreateConnection();
List <string> results = new List <string>();
string amt;
string side;
SQLiteCommand sqlite_cmd;
//var sqlCmd = $"SELECT Side, Amount FROM (SELECT * FROM Position_Data WHERE Strategy = {signalFile.StrategyName} ORDER BY OrderId DESC LIMIT 2)ORDER BY OrderId ASC;";
var sqlCmd = $"SELECT Side, Amount FROM Position_Data where Strategy = '{signalFile.StrategyName}' LIMIT 2 OFFSET(SELECT COUNT(*) FROM Position_Data WHERE Strategy = '{signalFile.StrategyName}') - 2;";
sqlite_cmd = sqlite_conn.CreateCommand();
sqlite_cmd.CommandText = sqlCmd;
using (SQLiteDataReader sqlite_datareader = sqlite_cmd.ExecuteReader())
{
while (sqlite_datareader.Read())
{
side = (string)sqlite_datareader["Side"];
decimal t = (decimal)sqlite_datareader["Amount"];
amt = Convert.ToString(t);
results.Add(side);
results.Add(amt);
}
}
sqlite_conn.Close();
if (results.Count > 2)
{
string side1 = results[0];
//string side2 = results[2];
decimal amt1 = Convert.ToDecimal(results[1]);
decimal amt2 = Convert.ToDecimal(results[3]);
int multiplier = GetMultiplier(strategy);
decimal proftLoss = (side1 == "BUY") ? ((amt2 - amt1) * multiplier) : ((amt1 - amt2) * multiplier);
proftLoss *= strategy.LotSize;
string pnl = string.Format("{0:C2}", proftLoss);
string type = (side1 == "BUY") ? " Long " : " Short ";
string msg = string.Format(signalFile.StrategyName + type + "trade Pnl: {0:C2} ", proftLoss);
log.Info(msg);
UpdateProfitLoss(log, signalFile, pnl);
}
}
private double GetSignalFileLimitPrice(FuturesContract futuresContract, OrderDetails orderDetails, SignalFile signalFile, Strategy strategy, Tuple <bool, bool, int> db)
{
double tick;
double limitPrice = signalFile.LimitPrice;
switch (strategy.Symbol)
{
case "QM":
tick = FuturesContract.GetTickSize(futuresContract);
decimal nearOf = 0.025M;
//tick *= (signalFile.EMAAngle < 40 && signalFile.EMAAngle > -40) ? @params.crudeSpread : 4;
tick *= (signalFile.Trend < 40) ? @params.crudeSpread : 4;
if (orderDetails.BuyOrSell == "BUY")
{
limitPrice -= tick;
}
else if (orderDetails.BuyOrSell == "SELL")
{
limitPrice += tick;
}
decimal _limitPrice = Convert.ToDecimal(limitPrice);
_limitPrice = Precision.UltimateRoundingFunction(_limitPrice, nearOf, 0.49M);
limitPrice = Convert.ToDouble(_limitPrice);
return(limitPrice);
case "MES":
tick = FuturesContract.GetTickSize(futuresContract);
tick *= (signalFile.EMAAngle <40 && signalFile.EMAAngle> -40) ? @params.sp500Spread : @params.sp500Spread / 2;
if (signalFile.Adx < 15)
{
if (orderDetails.BuyOrSell == "BUY")
{
limitPrice -= tick;
}
else if (orderDetails.BuyOrSell == "SELL")
{
limitPrice += tick;
}
}
return(limitPrice);
case "MGC":
tick = FuturesContract.GetTickSize(futuresContract);
if (signalFile.Adx < 15)
{
tick *= 1;
if (orderDetails.BuyOrSell == "BUY")
{
limitPrice -= tick;
return(limitPrice);
}
else if (orderDetails.BuyOrSell == "SELL")
{
limitPrice += tick;
return(limitPrice);
}
}
else
{
tick *= 2;
if (orderDetails.BuyOrSell == "BUY")
{
limitPrice += tick;
return(limitPrice);
}
else if (orderDetails.BuyOrSell == "SELL")
{
limitPrice -= tick;
return(limitPrice);
}
}
break;
}
return(limitPrice);
}
private double GetBrokerLimitPrice(FuturesContract futuresContract, OrderDetails orderDetails, Prices prices, Strategy strategy, Tuple <bool, bool, int> db, SignalFile signalFile)
{
double tick = FuturesContract.GetTickSize(futuresContract);
double limitPrice = 0;
switch (strategy.Symbol)
{
case "QM":
//tick *= (db.Item3 == 0 || db.Item3 != 0) ? @params.crudeSpread : 1;
//if (signalFile.Macd == 1)
//{
// tick *= (signalFile.Trend < 40 && orderDetails.BuyOrSell == "SELL") ? @params.crudeSpread : 4;
//}
//else if (signalFile.Macd == 2)
//{
// tick *= (signalFile.Trend < 40 && orderDetails.BuyOrSell == "SELL") ? @params.crudeSpread : 3;
//}
//if (signalFile.Macd == -1)
//{
// tick *= (signalFile.Trend < 40 && orderDetails.BuyOrSell == "BUY") ? @params.crudeSpread : 4;
//}
//else if (signalFile.Macd == -2)
//{
// tick *= (signalFile.Trend < 40 && orderDetails.BuyOrSell == "BUY") ? @params.crudeSpread : 3;
//}
if (orderDetails.BuyOrSell == "BUY")
{
//If Up trend than our bid is spread = 2 and offer is @params.crudeSpread = 5
//tick *= (signalFile.EMAAngle < 40 && signalFile.EMAAngle > -40) ? @params.crudeSpread : 8;
tick *= (signalFile.Trend < 40) ? @params.crudeSpread : 4;
limitPrice = Math.Min(prices.BidPrice, signalFile.LimitPrice); //prices.BidPrice;
limitPrice -= tick;
}
else if (orderDetails.BuyOrSell == "SELL")
{
//If Down trend than our offer is spread = 2 and out bid is @params.crudeSpread = 5
//tick *= (signalFile.EMAAngle < 40 && signalFile.EMAAngle > -40) ? @params.crudeSpread : 8;
tick *= (signalFile.Trend < 40) ? @params.crudeSpread : 4;
limitPrice = Math.Max(prices.AskPrice, signalFile.LimitPrice); //prices.AskPrice;
limitPrice += tick;
}
return(limitPrice);
case "MES":
//tick *= (db.Item3 == 0 || db.Item3 != 0) ? @params.sp500Spread : 1;
//tick *= (signalFile.EMAAngle < 40 && signalFile.EMAAngle > -40) ? @params.sp500Spread : @params.sp500Spread ;
tick *= (signalFile.Trend < 40) ? @params.sp500Spread : 5;
if (orderDetails.BuyOrSell == "BUY")
{
limitPrice = Math.Min(prices.BidPrice, signalFile.LimitPrice);
limitPrice -= tick;
}
else if (orderDetails.BuyOrSell == "SELL")
{
limitPrice = Math.Max(prices.AskPrice, signalFile.LimitPrice);
limitPrice += tick;
}
return(limitPrice);
}
return(limitPrice);
}
public static Transactions CheckLastPositionDataFromDB(Transactions transactions, Strategy strategy, SignalFile signalFile, SimpleLogger log)
{
string[] dbResults;
if (signalFile.StrategyName != strategy.StrategyName)
{
log.Warning($"Strategy {signalFile.StrategyName} does exist in Position_Data table.");
}
else
{
dbResults = DBFunctions.GetLastTradeSideFromPositionDataTable(log, strategy);
transactions.LastTradeSideText = dbResults[1];
transactions.Strategy = dbResults[2];
if (transactions.LastTradeSideText == "BUY" && signalFile.StrategyName == transactions.Strategy)
{
transactions.LastTradeSide = 1;
}
else if (transactions.LastTradeSideText == "SELL" && signalFile.StrategyName == transactions.Strategy)
{
transactions.LastTradeSide = -1;
}
else if (string.IsNullOrEmpty(transactions.LastTradeSideText))
{
transactions.LastTradeSide = 0;
}
}
return(transactions);
}
private double ExecuteOrder(FuturesContract futuresContract, SignalFile signalFile, OrderDetails orderDetails, Strategy strategy, SimpleLogger log, Tuple <bool, bool, int> db)
{
Prices prices = new Prices();
prices = prices.StartListener(clientSocket, contract, strategy, prices, log);
double limitPrice = GetPrices(futuresContract, signalFile, strategy, orderDetails, prices, db);
if (limitPrice <= 0)
{
limitPrice = signalFile.LimitPrice;
log.Warning($"LimitPrice for {strategy.StrategyName} is null using signalFile price {signalFile.LimitPrice}");
}
//Use market orders overnight so we don't miss getting filled
//string orderType = OverNight(signalFile, db);
//if (string.IsNullOrEmpty(orderType))
//{
// orderType = strategy.OrderType;
//}
Order parent = new Order();
Order openOrder = new Order();
List <Order> orders = new List <Order>();
if (db.Item3 != 0) //If there is a position
{
//Use market orders overnight so we don't miss getting filled
string orderType = OverNight(signalFile, db);
//if (string.IsNullOrEmpty(orderType))
//{
// orderType = strategy.OrderType;
//}
//Close position with market order
parent = new Order()
{
OrderId = OrderDetails.NextOrderId++,
Action = orderDetails.BuyOrSell,
OrderType = (string.IsNullOrEmpty(orderType) ? strategy.OrderType : orderType), //strategy.OrderType, //"MKT",
TotalQuantity = strategy.LotSize,
LmtPrice = (orderDetails.BuyOrSell == "SELL") ? prices.BidPrice : prices.AskPrice, //limitPrice,
AuxPrice = (orderDetails.BuyOrSell == "SELL") ? prices.BidPrice : prices.AskPrice, //limitPrice,
Tif = "GTC",
Transmit = true
};
openOrder = new Order()
{
OrderId = OrderDetails.NextOrderId++,
Action = orderDetails.BuyOrSell,
OrderType = strategy.OrderType, //(strategy.OrderType == "MKT" ? strategy.OrderType : orderType),
TotalQuantity = strategy.LotSize,
LmtPrice = limitPrice,
AuxPrice = limitPrice,
Tif = "GTC",
Transmit = true
};
orders = new List <Order>()
{
parent,
openOrder
};
}
else
{
openOrder = new Order()
{
OrderId = OrderDetails.NextOrderId++,
Action = orderDetails.BuyOrSell,
OrderType = strategy.OrderType, //(strategy.OrderType == "MKT" ? strategy.OrderType : orderType),
TotalQuantity = orderDetails.LotSize,
LmtPrice = limitPrice,
AuxPrice = limitPrice,
Tif = "GTC",
Transmit = true
};
orders = new List <Order>()
{
openOrder
};
}
foreach (Order o in orders)
{
clientSocket.placeOrder(o.OrderId, contract, o);
}
orderDetails.OrderId = parent.OrderId.ToString();
orderDetails.OrderStatus = "Submitted";
if (db.Item3 != 0)
{
log.Signal($"Sent Closing {parent.Action} {parent.OrderType} Order for {strategy.Symbol} LimitPrice:{parent.LmtPrice} LotSize:{parent.TotalQuantity} OrderId:{parent.OrderId}");
log.Signal($"Sent Opening {openOrder.Action} {openOrder.OrderType} Order for {strategy.Symbol} LimitPrice:{openOrder.LmtPrice} LotSize:{openOrder.TotalQuantity} OrderId:{openOrder.OrderId}");
}
else
{
log.Signal($"Sent Opening {openOrder.Action} {openOrder.OrderType} Order for {strategy.Symbol} LimitPrice:{openOrder.LmtPrice} LotSize:{openOrder.TotalQuantity} OrderId:{openOrder.OrderId}");
}
OrderDetails.OrderIdList.DataList.Add(orderDetails.OrderId);
return(limitPrice);
}
//public string OrderType { get; set; }
//public int MaxPosition { get; set; }
//public int LotSize { get; set; }
public FuturesContract GetContractDetails(Contract contract, FuturesContract futuresContract, SignalFile signalFile)
{
if (signalFile.Symbol.Contains("ES"))
{
signalFile.Symbol = "ES";
//switch (signalFile.StrategyName)
//{
// case "MES TMA_Slope Kase Bar 3.75":
contract.LocalSymbol = string.Empty;
contract.Symbol = "MES"; //MES ***USE MICRO CONTRACT FOR GO LIVE
contract.SecType = @params.sp500SecType;
contract.LastTradeDateOrContractMonth = @params.sp500Expiry;
contract.Exchange = @params.sp500Exchange;
contract.Currency = @params.sp500Currency;
futuresContract.Symbol = contract.Symbol;
futuresContract.Exchange = @params.sp500Exchange;
//break;
//default:
// contract.LocalSymbol = string.Empty;
// contract.Symbol = signalFile.Symbol; //MES ***USE MICRO CONTRACT FOR GO LIVE
// contract.SecType = @params.sp500SecType;
// contract.LastTradeDateOrContractMonth = @params.sp500Expiry;
// contract.Exchange = @params.sp500Exchange;
// contract.Currency = @params.sp500Currency;
// Symbol = contract.Symbol;
// Exchange = @params.sp500Exchange;
// break;
//}
}
else if (signalFile.Symbol.Contains("QM"))
{
signalFile.Symbol = "QM";
contract.LocalSymbol = string.Empty;
contract.Symbol = signalFile.Symbol;
contract.SecType = @params.crudeSecType;
contract.LastTradeDateOrContractMonth = @params.crudeExpiry;
contract.Exchange = @params.crudeExchange;
contract.Currency = @params.crudeCurrency;
futuresContract.Symbol = contract.Symbol;
futuresContract.Exchange = @params.crudeExchange;
}
else if (signalFile.Symbol.Contains("CL"))
{
signalFile.Symbol = "CL";
contract.LocalSymbol = string.Empty;
contract.Symbol = signalFile.Symbol;
contract.SecType = @params.crudeSecType;
contract.LastTradeDateOrContractMonth = @params.crudeExpiry;
contract.Exchange = @params.crudeExchange;
contract.Currency = @params.crudeCurrency;
futuresContract.Symbol = contract.Symbol;
futuresContract.Exchange = @params.crudeExchange;
}
else if (signalFile.Symbol.Contains("GC"))
{
signalFile.Symbol = "GC";
contract.LocalSymbol = string.Empty;
contract.Symbol = "MGC"; //signalFile.Symbol;
contract.SecType = @params.goldSecType;
contract.LastTradeDateOrContractMonth = @params.goldExpiry;
contract.Exchange = @params.goldExchange;
contract.Currency = @params.goldCurrency;
futuresContract.Symbol = contract.Symbol;
futuresContract.Exchange = @params.goldExchange;
}
else if (signalFile.Symbol.Contains("TY"))
{
signalFile.Symbol = "ZN";
contract.LocalSymbol = string.Empty;
contract.Symbol = signalFile.Symbol;
contract.SecType = "FUT";
contract.LastTradeDateOrContractMonth = @params.crudeExpiry;
contract.Exchange = "ECBOT";
contract.Currency = "USD";
futuresContract.Symbol = signalFile.Symbol;
futuresContract.Exchange = "ECBOT";
}
return(futuresContract);
}
public static SignalFile ParseSignalFile(SignalFile signalFile, SimpleLogger log)
{
string strColumn;
foreach (KeyValuePair <int, string> column in FileColumns)
{
strColumn = GetWantedText(signalFile.LastFileLine, column.Value);
if (string.IsNullOrEmpty(strColumn))
{
log.Warning($"SignalFile field {column.Value} missing data.");
break;
}
switch (column.Value)
{
case "strategy:":
signalFile.StrategyName = strColumn;
break;
case "symbol:":
signalFile.Symbol = strColumn;
break;
case "entry_date:":
signalFile.TradeDate = strColumn;
break;
case "entry_time:":
signalFile.TradeDateTime = strColumn;
break;
case "signal:":
signalFile.Signal = int.Parse(strColumn, CultureInfo.InvariantCulture);
break;
case "entry_price:":
signalFile.EntryPrice = strColumn;
break;
case "exit:":
signalFile.Exit = strColumn.Substring(0, 1);
break;
case "adx:":
signalFile.Adx = int.Parse(strColumn, CultureInfo.InvariantCulture);
break;
case "emaAngle:":
signalFile.EMAAngle = double.Parse(strColumn, CultureInfo.InvariantCulture);
break;
case "trend:":
signalFile.Trend = double.Parse(strColumn, CultureInfo.InvariantCulture);
break;
case "macd:":
signalFile.Macd = int.Parse(strColumn, CultureInfo.InvariantCulture);
break;
}
}
signalFile.LimitPrice = double.Parse(signalFile.EntryPrice, CultureInfo.InvariantCulture);
signalFile.Output = $"strategy:{signalFile.StrategyName}, symbol:{signalFile.Symbol}, entryDate:{signalFile.TradeDate}, entryDateTime: {signalFile.TradeDateTime} signal:{signalFile.Signal}, price:{signalFile.EntryPrice}, exit:{signalFile.Exit}, adx:{signalFile.Adx}, emaAngle:{signalFile.EMAAngle}, trend:{signalFile.Trend}, macd:{signalFile.Macd}";
log.Signal("[PARSED DATA] " + signalFile.Output);
return(signalFile);
}
public static void GetStrategyId(FuturesContract futuresContract, Strategy strategy, SignalFile signalFile, SimpleLogger log)
{
var strategyInfo = from s in StrategyList
where s.Name == signalFile.StrategyName
select new { s.Id, s.Name, s.Ticker, s.OType, s.Contracts, s.MaxPosition, s.Enabled };
var symbolMaxPosition = from s in StrategyList
where s.Ticker == futuresContract.Symbol
group s by s.Ticker into sg
orderby sg.Key
select new { sg.Key, Total = sg.Sum(x => x.MaxPosition) };
foreach (var g in strategyInfo)
{
strategy.StrategyId = g.Id;
strategy.Symbol = g.Ticker;
strategy.StrategyName = g.Name;
strategy.OrderType = g.OType;
strategy.LotSize = g.Contracts;
strategy.StrategyMaxPosition = g.MaxPosition;
strategy.Status = g.Enabled;
foreach (var c in symbolMaxPosition)
{
strategy.MaxPositionForSymbol = c.Total;
}
}
log.Info($"[STRATEGY INFO] StrategyId:{strategy.StrategyId} StrategyName:{strategy.StrategyName}");
}
public Prices StartListener(EClientSocket clientSocket, Contract contract, Strategy strategy, Prices prices, SimpleLogger log)
{
string ticker;
string strBid;
string strAsk;
double bid;
double ask;
int maxLoopCount = 30;
Prices.IBDepthBidPriceFlag = false;
Prices.IBDepthAskPriceFlag = false;
if (strategy.Symbol != "MGC")
{
int cnt = 0;
clientSocket.reqMarketDepth(strategy.StrategyId, contract, 1, null);
while (true)
{
ticker = SignalFile.GetWantedText(Prices.SideOne, "TickerId:");
strBid = SignalFile.GetWantedText(Prices.SideOne, "Price:");
strAsk = SignalFile.GetWantedText(Prices.SideTwo, "Price:");
if (Prices.IBDepthBidPriceFlag && Prices.IBDepthAskPriceFlag)
{
bid = Convert.ToDouble(strBid);
ask = Convert.ToDouble(strAsk);
if (bid > 0 && ask > 0)
{
prices.BidPrice = bid;
prices.AskPrice = ask;
clientSocket.cancelMktDepth(strategy.StrategyId);
log.Info($"Received Market Depth for TickerId:{ticker}, Symbol:{strategy.Symbol}, Bid:{strBid}, Ask:{strAsk}");
break;
}
else
{
log.Info($"Unable to get Market Depth for TickerId:{ticker}, Market Depth Bid:{strBid}, Ask:{strAsk}");
clientSocket.cancelMktDepth(strategy.StrategyId);
break;
}
}
if (cnt > maxLoopCount)
{
clientSocket.cancelMktDepth(strategy.StrategyId);
log.Warning($"Unable to get Market Depth for TickerId:{ticker}, Symbol:{strategy.Symbol}, Market Depth Bid:{strBid}, Ask:{strAsk}");
break;
}
log.Info($"Getting Market Depth... {cnt}");
cnt++;
}
}
if (prices.BidPrice <= 0 || prices.AskPrice <= 0)
{
int cnt = 0;
clientSocket.reqMktData(strategy.StrategyId, contract, "", false, null);
Prices.IBBidPriceFlag = false;
Prices.IBAskPriceFlag = false;
while (true)
{
ticker = SignalFile.GetWantedText(Prices.SideOne, "TickerId:");
strBid = SignalFile.GetWantedText(Prices.FieldOne, "Price:");
strAsk = SignalFile.GetWantedText(Prices.FieldTwo, "Price:");
bid = Convert.ToDouble(strBid);
ask = Convert.ToDouble(strAsk);
if (Prices.IBBidPriceFlag && Prices.IBAskPriceFlag)
{
if (bid > 0 && ask > 0)
{
prices.BidPrice = bid;
prices.AskPrice = ask;
clientSocket.cancelMktData(strategy.StrategyId);
log.Info($"Received Snapshot Data for TickerId:{ticker}, Symbol:{strategy.Symbol}, Bid:{strBid}, Ask:{strAsk}");
break;
}
else
{
log.Info($"Unable to get Snapshot Data for TickerId:{ticker}, Symbol:{strategy.Symbol}, Bid:{strBid}, Ask:{strAsk}");
clientSocket.cancelMktDepth(strategy.StrategyId);
break;
}
}
if (cnt >= maxLoopCount)
{
clientSocket.cancelMktData(strategy.StrategyId);
log.Warning($"Unable to get Snapshot Data for TickerId:{ticker}, Symbol:{strategy.Symbol}, Bid:{strBid}, Ask:{strAsk}");
break;
}
log.Info($"Getting Price Snapshot Data... {cnt}");
cnt++;
}
}
return(prices);
}
