private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
{
formClosing = true;
//if (stocks != null && stocks.Count() > 0)
// WriteToXmlFile<BindingList<Stock>>(Robinhood.__stocksFile, stocks);
Robinhood.SignOut();
}
private void UpdateMarketQuotes(MainForm mainForm)
{
//List<Stock> quotes = new List<Stock>();
if (mainForm.stocks.Count() == 0)
{
return; //quotes = mainForm.stocks.Union(quotes).ToList();
}
List <Stock> marketStocks = Robinhood.GetQuote(mainForm.stocks.ToList());
foreach (Stock stock in marketStocks)
{
//relying on update recent order to add pending orders
ThreadedBindingList <OrderSnapshot> pendingOrders = null;
if (stock.PendingOrders != null)
{
lock (stock.PendingOrders)
{
pendingOrders = new ThreadedBindingList <OrderSnapshot>(AllPendingOrders.Where(o => o.InstrumentId == stock.InstrumentURL).ToList());
}
}
else
{
pendingOrders = new ThreadedBindingList <OrderSnapshot>(AllPendingOrders.Where(o => o.InstrumentId == stock.InstrumentURL).ToList());
}
if (pendingOrders.Count > 0)
{
stock.PendingOrders = pendingOrders;
}
else
{
stock.PendingOrders = null;
}
mainForm.PositionsGrid.BeginInvoke((Action) delegate
{
lock (mainForm.stocks)
{
int index = mainForm.stocks.ToList()
.FindIndex(s => s.Ticker == stock.Ticker);
if (index >= 0)
{
mainForm.stocks[index] = stock;
}
}
});
if (stock.NoOfShares > 0)
{
UpdateOwnedStock(mainForm, stock);
}
else
{
//don't own this stock
stock.CostBasis = 0.00m;
}
}
}
/// <summary>
/// function to place trail stop order in a thread
/// </summary>
/// <param name="param"></param>
void TrailStopper(object param)
{
KeyValuePair <Stock, decimal> input = (KeyValuePair <Stock, decimal>)param;
Stock stock = input.Key;
decimal newVal = input.Value;
int attempt = 10;
while (attempt > 0)
{
try
{
//cancel stoploss
Robinhood.CancelThrdComp = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(Robinhood.CancelOrder,
new KeyValuePair <Form, ThreadedBindingList <OrderSnapshot> >(this, stock.PendingOrders));
if (stock.PendingOrders != null && stock.PendingOrders.Count() > 0)
{
Robinhood.CancelThrdComp.WaitOne();
}
while (AllPendingOrders.Any(o => o.InstrumentId == stock.InstrumentURL))
{
Thread.Sleep(200);
}
stock.StopLoss.Price = newVal;
//place adjusted stop loss
Robinhood.PlaceOrder(stock, TimeInForce.GoodTillCancel, Robinhood.TradeStep.StopLoss, this);
lock (trailStopping)
{
trailStopping.Remove(stock.Ticker);
}
logger.Info("Order plaed at " + newVal.ToString());
//when order is there exit
while (stock.PendingOrders == null)
{
Thread.Sleep(200);
}
break;
}
catch (Exception e)
{
logger.Error(e);
}
Thread.Sleep(1000);
attempt--;
}
lock (trailStopping)
{
trailStopping.Remove(stock.Ticker);
}
}
private void loginBackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
KeyValuePair <string, string> creden = (KeyValuePair <string, string>)e.Argument;
try
{
Robinhood.Init(creden.Key, creden.Value);
e.Result = true;
}
catch
{
resultLabel.BeginInvoke((Action) delegate
{
resultLabel.Text = "Login Failed, Please confirm username password";
});
e.Result = false;
}
}
/// <summary>
/// function to place price target order in a thread
/// </summary>
/// <param name="param"></param>
void PriceTargeter(object param)
{
KeyValuePair <Stock, decimal> input = (KeyValuePair <Stock, decimal>)param;
Stock stock = input.Key;
decimal newVal = input.Value;
int attempt = 10;
while (attempt > 0)
{
try
{
//cancel stoploss
Robinhood.CancelThrdComp = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(Robinhood.CancelOrder,
new KeyValuePair <Form, ThreadedBindingList <OrderSnapshot> >(this, stock.PendingOrders));
Robinhood.CancelThrdComp.WaitOne();
while (AllPendingOrders.Any(o => o.InstrumentId == stock.InstrumentURL))
{
Thread.Sleep(200);
}
//place adjusted stop loss
Robinhood.PlaceOrder(stock, TimeInForce.GoodTillCancel, Robinhood.TradeStep.ProfitTarget, this);
stock.PriceTarget.NoOfShares = 0;
logger.Info("Order plaed at " + newVal.ToString());
break;
}
catch (Exception e)
{
logger.Error(e);
}
Thread.Sleep(1000);
attempt--;
}
lock (priceTargeting)
{
priceTargeting.Remove(stock.Ticker);
}
}
void PlaceEntry(object param)
{
Stock stock = (Stock)param;
Robinhood.PlaceOrder(stock, TimeInForce.GoodTillCancel, Robinhood.TradeStep.Entry, this);
}
void PlaceStop(object param)
{
Robinhood.PlaceOrder(stock, TimeInForce.GoodTillCancel, Robinhood.TradeStep.StopLoss, this);
}
void PlacePT(object param)
{
Stock stock = (Stock)param;
Robinhood.PlaceOrder(stock, TimeInForce.GoodTillCancel, Robinhood.TradeStep.ProfitTarget, this);
}
void StockUpdater(object parm)
{
HoldingForm form = (HoldingForm)parm;
while (true)
{
try
{
if (stopThreads)
{
break;
}
stock = Robinhood.GetQuote(new List <Stock>()
{
stock
}).First();
string quote = stock.Quote;
form.labelQuote.Invoke((Action) delegate
{
form.labelQuote.Text = quote;
form.labelQuote.ForeColor = form.stock.Color;
});
form.labelAskPrice.Invoke((Action) delegate
{
form.labelAskPrice.Text = "$" + stock.AskPrice.ToString();
form.labelBidPrice.Text = "$" + stock.BidPrice.ToString();
});
///////////////////////////
if (stock.Entry.FollowPrice == PricePointControl.FollowPrice.AtAsk)
{
form.Entry.numericUpDownValue.Invoke((Action) delegate
{
form.Entry.numericUpDownValue.Value = stock.AskPrice;
});
}
if (stock.Entry.FollowPrice == PricePointControl.FollowPrice.AtLastTradedPrice)
{
form.Entry.numericUpDownValue.Invoke((Action) delegate
{
form.Entry.numericUpDownValue.Value = stock.LastTradePrice + 0.01m;
});
}
if (stock.Entry.FollowPrice == PricePointControl.FollowPrice.AtBid)
{
form.Entry.numericUpDownValue.Invoke((Action) delegate
{
form.Entry.numericUpDownValue.Value = stock.BidPrice;
});
}
/////////////////////////////////////////////
if (stock.StopLoss.FollowPrice == PricePointControl.FollowPrice.AtAsk)
{
form.Stop.numericUpDownValue.Invoke((Action) delegate
{
form.Stop.numericUpDownValue.Value = stock.AskPrice;
});
}
if (stock.StopLoss.FollowPrice == PricePointControl.FollowPrice.AtBid)
{
form.Stop.numericUpDownValue.Invoke((Action) delegate
{
form.Stop.numericUpDownValue.Value = stock.BidPrice;
});
}
if (stock.StopLoss.FollowPrice == PricePointControl.FollowPrice.AtLastTradedPrice)
{
form.Stop.numericUpDownValue.Invoke((Action) delegate
{
form.Stop.numericUpDownValue.Value = stock.LastTradePrice;
});
}
///////////////
if (stock.PriceTarget.FollowPrice == PricePointControl.FollowPrice.AtAsk)
{
form.PriceTarget.numericUpDownValue.Invoke((Action) delegate
{
form.PriceTarget.numericUpDownValue.Value = stock.AskPrice;
});
}
if (stock.PriceTarget.FollowPrice == PricePointControl.FollowPrice.AtLastTradedPrice)
{
form.PriceTarget.numericUpDownValue.Invoke((Action) delegate
{
form.PriceTarget.numericUpDownValue.Value = stock.LastTradePrice;
});
}
if (stock.PriceTarget.FollowPrice == PricePointControl.FollowPrice.AtBid)
{
form.PriceTarget.numericUpDownValue.Invoke((Action) delegate
{
form.PriceTarget.numericUpDownValue.Value = stock.BidPrice;
});
}
form.labelMarketValue.Invoke((Action) delegate
{
form.labelMarketValue.Text = "Market Value: $" + Math.Round(stock.LastTradePrice * form.NoOfShares.Value, 2).ToString();
});
form.bidAskRationLabel.Invoke((Action) delegate
{
bidAskRationLabel.Text = stock.BidAskSpread.ToString();
});
if (stock.NoOfShares > 0 && (stock.PendingOrders == null || !stock.PendingOrders.Any(o => o.Side == Side.Sell && o.Trigger == "stop")))
{
Stop.Invoke((Action) delegate
{
if (Stop.placeOrderButton.BackColor == SystemColors.ControlLightLight)
{
Stop.placeOrderButton.BackColor = Color.IndianRed;
Stop.placeOrderButton.ForeColor = Color.White;
Stop.placeOrderButton.Text = "No Stop Order";
}
else
{
Stop.placeOrderButton.BackColor = SystemColors.ControlLightLight;
Stop.placeOrderButton.ForeColor = SystemColors.WindowText;
Stop.placeOrderButton.Text = "Place Order";
}
});
}
else
{
Stop.Invoke((Action) delegate
{
Stop.placeOrderButton.BackColor = SystemColors.ButtonFace;
Stop.placeOrderButton.ForeColor = SystemColors.WindowText;
Stop.placeOrderButton.Text = "Place Order";
});
}
this.BeginInvoke((Action) delegate
{
this.UpdatePendingOrder();
});
}
catch (Exception e)
{
if (shown && form.IsHandleCreated)
{
form.labelQuote.Invoke((Action) delegate
{
form.labelQuote.Text = e.Message;
form.labelQuote.ForeColor = Color.IndianRed;
});
}
}
Thread.Sleep(form.refreshTime);
}
}
/// <summary>
/// this thread updates all the quotes on the grids also downloads
/// also download latest portfolio from RH
/// </summary>
/// <param name="form"></param>
void MarketPerfomanceUpdater(object form)
{
MainForm mainForm = (MainForm)form;
int i = 0;
decimal lastprice = 0;
while (true)
{
if (mainForm.formClosing)
{
break;
}
try
{
Stock[] quotes = new Stock[] {
new Stock()
{
Ticker = mainForm.market.Ticker
},
new Stock()
{
Ticker = mainForm.TVIX.Ticker
},
new Stock()
{
Ticker = mainForm.nugt.Ticker
}
};
Account account = Robinhood.rh.DownloadAllAccounts().Result.First();
IList <Position> positions = Robinhood.rh.DownloadPositions(account.PositionsUrl.Uri.ToString());
foreach (Position position in positions)
{
Stock stock = mainForm.stocks.FirstOrDefault(s => s.InstrumentURL == position.InstrumentUrl.Uri.ToString());
if (stock == null)
{
if ((int)position.Quantity == 0)
{
continue; //skip stocks in RH watchlist
}
var q = Robinhood.rh.DownloadInstrument(position.InstrumentUrl.Uri.ToString());
stock = new Stock()
{
Ticker = q.Result.Symbol, NoOfShares = (int)position.Quantity, CostBasis = position.AverageBuyPrice
};
mainForm.stocks.Add(stock);
}
else
{
stock.NoOfShares = (int)position.Quantity;
if (stock.NoOfShares > 0)
{
stock.CostBasis = position.AverageBuyPrice;
}
else
{
stock.CostBasis = 0.00m;
}
}
}
if (mainForm.stocks.Count() > 0)
{
quotes = mainForm.stocks.Union(quotes).ToArray();
}
List <Stock> marketStocks = Robinhood.GetQuote(quotes.ToList());
foreach (Stock stock in marketStocks)
{
if (stock.Ticker == market.Ticker)
{
mainForm.market = stock;
}
else if (stock.Ticker == TVIX.Ticker)
{
mainForm.TVIX = stock;
}
else if (stock.Ticker == nugt.Ticker)
{
mainForm.nugt = stock;
}
//relying on update recent order to add pending orders
ThreadedBindingList <OrderSnapshot> pendingOrders = null;
if (stock.PendingOrders != null)
{
lock (stock.PendingOrders)
{
pendingOrders = new ThreadedBindingList <OrderSnapshot>(AllPendingOrders.Where(o => o.InstrumentId == stock.InstrumentURL).ToList());
}
}
else
{
pendingOrders = new ThreadedBindingList <OrderSnapshot>(AllPendingOrders.Where(o => o.InstrumentId == stock.InstrumentURL).ToList());
}
if (pendingOrders.Count > 0)
{
stock.PendingOrders = pendingOrders;
}
else
{
stock.PendingOrders = null;
}
mainForm.PositionsGrid.BeginInvoke((Action) delegate
{
lock (mainForm.stocks)
{
int index = mainForm.stocks.ToList()
.FindIndex(s => s.Ticker == stock.Ticker);
if (index >= 0)
{
mainForm.stocks[index] = stock;
}
}
});
if (stock.NoOfShares > 0)
{
if (!mainForm.tabControlMain.TabPages[1].Text.Contains("Loading") &&
!trailStopping.Contains(stock.Ticker))
{
//implementing trailing loss
if (stock.StopLoss != null &&
stock.StopLoss.Execution == PricePointControl.Execution.Trailing &&
stock.StopLoss.TrailPrcntg > 0 && stock.NoOfShares > 0)
{
//PT reached sell
if (stock.StopLoss.Price >= stock.LastTradePrice)
{
stock.StopLoss.Price = 0; //reset stop loss
}
decimal newVal = (stock.StopLoss.Price +
(stock.StopLoss.Price * stock.StopLoss.TrailPrcntg / 100));
if (stock.LastTradePrice >
newVal
) // within 2% of price target place limit sell
{
newVal = Math.Round(stock.LastTradePrice - (stock.LastTradePrice * stock.StopLoss.TrailPrcntg / 100), 2);
if (stock.PendingOrders == null || (stock.PendingOrders != null && !stock.PendingOrders.Any(o => o.StopPrice <= newVal + 0.2m && o.StopPrice >= newVal - 0.2m)))
{
if (stock.NoOfShares < stock.StopLoss.NoOfShares)
{
stock.NoOfShares = stock.StopLoss.NoOfShares;
}
stock.StopLoss.Trigger = TriggerType.Stop;
KeyValuePair <Stock, decimal> input = new KeyValuePair <Stock, decimal>(stock, newVal);
lock (trailStopping)
{
trailStopping.Add(stock.Ticker);
}
ThreadPool.QueueUserWorkItem(TrailStopper, input);
}
}
}
//no stop loss place it if manage trade selected
if (stock.ManageTrade && stock.NoOfShares > 0 && stock.StopLoss.Execution != PricePointControl.Execution.Trailing)
{
decimal newVal;
decimal?currentStop = null;
if (stock.PendingOrders != null && stock.PendingOrders.Count() > 0)
{
currentStop = (decimal)stock.PendingOrders.First().Price;
}
//if price has moved > 2% from cost
newVal = Math.Round(stock.CostBasis + (stock.CostBasis * 2.10m / 100), 2);
if (stock.LastTradePrice > newVal)
{
//price has moved 2% from cost move stop to break even
newVal = Math.Round(stock.CostBasis + (stock.CostBasis * 2.00m / 100), 2);
}
else
{
//place stop loss at max
newVal = Math.Round(stock.CostBasis - (stock.CostBasis * stock.MaxPrctgLoss / 100), 2);
stock.StopLoss.StopOffset = 0.02m;
stock.StopLoss.Trigger = TriggerType.Stop;
//price has already moved at or below stop loss liquidate immiediately
if (stock.LastTradePrice <= newVal)
{
newVal = stock.LastTradePrice;
stock.StopLoss.Trigger = TriggerType.Immediate;
}
}
if (currentStop == null || currentStop <= newVal - 0.03m || currentStop >= newVal + 0.03m)
{
stock.StopLoss.NoOfShares = stock.NoOfShares;
stock.StopLoss.Price = newVal;
//place adjusted stop loss
KeyValuePair <Stock, decimal> input = new KeyValuePair <Stock, decimal>(stock, newVal);
lock (trailStopping)
{
trailStopping.Add(stock.Ticker);
}
ThreadPool.QueueUserWorkItem(TrailStopper, input);
}
}
}
//Checking if Price target reached
if (stock.PriceTarget != null && stock.NoOfShares > 0 &&
stock.PriceTarget.Price > 0 &&
stock.PriceTarget.NoOfShares > 0 &&
!priceTargeting.Contains(stock.Ticker))
{
//PT reached sell
if (stock.LastTradePrice + 0.02m >= stock.PriceTarget.Price) // within 2cent of price target place limit sell
{
KeyValuePair <Stock, decimal> input = new KeyValuePair <Stock, decimal>(stock, stock.PriceTarget.Price);
lock (priceTargeting)
{
priceTargeting.Add(stock.Ticker);
}
ThreadPool.QueueUserWorkItem(PriceTargeter, input);
}
}
}
else
{
//don't own this stock
stock.CostBasis = 0.00m;
}
}
//Updating market tickers
mainForm.BeginInvoke((MethodInvoker)(() =>
{
mainForm.marketLabel.Text = market.Quote;
mainForm.marketLabel.ForeColor = market.Color;
}));
mainForm.labelTVIX.BeginInvoke((Action) delegate
{
mainForm.labelTVIX.Text = TVIX.Quote;
mainForm.labelTVIX.ForeColor = TVIX.Color;
});
mainForm.nugtLabel.BeginInvoke((Action) delegate
{
mainForm.nugtLabel.Text = nugt.Quote;
mainForm.nugtLabel.ForeColor = nugt.Color;
});
//Updating account information
mainForm.buyPowerLabel.Invoke((Action) delegate
{
mainForm.buyPowerLabel.Text = "Buying Power: $" + Math.Round(account.CashBalance.BuyingPower, 2).ToString();
});
mainForm.labelUnsettled.Invoke((Action) delegate
{
mainForm.labelUnsettled.Text = "Unsettled: $" + Math.Round(account.CashBalance.UnsettledFunds, 2).ToString();
});
mainForm.labelCash.Invoke((Action) delegate
{
mainForm.labelCash.Text = "Cash: $" + Math.Round(account.CashBalance.BuyingPower + account.CashBalance.UnsettledFunds + account.CashBalance.CashHeldForOrders, 2).ToString();
});
mainForm.buttonAddStock.Invoke((Action) delegate
{
mainForm.buttonAddStock.Enabled = true;
});
if (mainForm.PositionsGrid.Enabled == false)
{
mainForm.PositionsGrid.Invoke((Action) delegate
{
mainForm.buttonAddStock.Enabled = true;
});
}
mainForm.PositionsGrid.Invoke((Action) delegate
{
UpdateGrids();
});
Thread.Sleep(refreshTime);
}
catch (AggregateException)
{
mainForm.BeginInvoke((MethodInvoker)(() =>
{
mainForm.marketLabel.Text = "Could not reach Robinhood, Check network connection";
mainForm.marketLabel.ForeColor = Color.IndianRed;
mainForm.marketLabel.BringToFront();
}));
}
catch (WebException e)
{
MessageBox.Show(e.ToString());
}
catch (HttpException e)
{
MessageBox.Show(e.ToString());
}
catch (Exception e)
{
MessageBox.Show(e.ToString());
logger.Error(e);
}
}
}
