/// <summary>Repopulate the tree grid of trades</summary> private void UpdateGrid(object sender = null, EventArgs args = null) { // Update the tree grid using differences so that expanded/collapsed nodes are preserved using (m_grid.SuspendLayout(true)) { var trades = Trades.Where(x => Bit.AllSet(x.State, Settings.UI.ShowTrades)).ToHashSet(); // Remove any root level nodes that aren't in the trades list m_grid.RootNode.Nodes.RemoveIf(x => !trades.Contains(x.DataBoundItem)); // Update the trades foreach (var trade in Trades.Where(x => Bit.AllSet(x.State, Settings.UI.ShowTrades))) { // Get the node for 'trade'. If the trade is not yet in the tree grid, add it var node = m_grid.RootNode.Nodes.FirstOrDefault(x => x.DataBoundItem == trade) ?? m_grid.RootNode.Nodes.Bind(trade); var orders = trade.Orders.Where(x => Bit.AllSet(x.State, Settings.UI.ShowTrades)).ToHashSet(); // Remove any orders not in the trade node.Nodes.RemoveIf(x => !orders.Contains(x.DataBoundItem)); // Add any orders not yet in the grid orders.RemoveWhere(x => node.Nodes.Any(n => n.DataBoundItem == x)); foreach (var order in orders.Where(x => Bit.AllSet(x.State, Settings.UI.ShowTrades))) { node.Nodes.Bind(order); } } } m_grid.Invalidate(); }
private async Task UpdateTrades() { List <Trade> newTrades = new List <Trade>(); if (Trades.Count == 0) { Trades.Add(new Trade { Status = TradeStatus.Empty }); } foreach (var trade in Trades.Where(t => t.Status != TradeStatus.Completed)) { var newTrade = await UpdateTrade(trade); if (newTrade != Trade.Empty) { newTrades.Add(newTrade); } } if (newTrades.Count > 0) { Trades.AddRange(newTrades); } var canceledTrades = Trades.Where(t => t.Status == TradeStatus.Canceled).ToList(); foreach (var canceledTrade in canceledTrades) { Trades.Remove(canceledTrade); } }
public Dictionary <Stock, int> GetHoldings(DateTime date) { return(Trades .Where(x => x.Key <= date) .Select(x => new { stock = x.Value.Stock, volume = (x.Value.Type == TransactionEnum.Buy ? 1 : -1) * x.Value.NumberOfShares }) .GroupBy(x => x.stock) .Select(x => new { stock = x.Key, total = x.Sum(_ => _.volume) }) .Where(x => x.total != 0) .ToDictionary(x => x.stock, x => x.total)); }
//gets the amount of tickets a vereniging has (from ordering AND TRADING) public int GetAmountTotalTicketsByVereniging(Vereniging vereniging) { int count = 0; count += GetAmountTicketsOrderedByVereniging(vereniging); //add tickets received from trades count += Trades.Where(t => t.To.GroepId == vereniging.GroepId).Sum(t => t.Amount); //removed tickets given away with trades count -= Trades.Where(t => t.From.GroepId == vereniging.GroepId).Sum(t => t.Amount); return(count); }
public void Recalculate() { if (status == positionStatus.Closed) { return; } quantity = Trades.Where(x => x.Status == tradeStatus.Active).Sum(y => y.quantity); price = Trades.Where(x => x.Status == tradeStatus.Active).Sum(y => y.price * y.quantity); if (quantity == 0) { status = positionStatus.Closed; } }
public async Task <IRequest <IEnumerable <ITrade> > > GetLastTradesAsync(string symbol, int count, string fromId) { IEnumerable <ITrade> trades; if (fromId != null) { trades = Trades.Where(t => t.Symbol == symbol && (long.Parse(t.Id) > long.Parse(fromId))); } else { trades = Trades.Where(t => t.Symbol == symbol); } return(new MarketRequest <IEnumerable <ITrade> >(RequestStatus.Completed, trades)); }
public IEnumerable <TradeModel> GetValleys(decimal percent, double timeHours) { long lastValleyDate = 0; var filteredTrades = from trade in Trades .Where(t => { if (t.IsValley(percent, timeHours, lastValleyDate)) { lastValleyDate = t.T; return(true); } return(false); }) select trade; return(filteredTrades); }
/// <summary> /// Gets the Volume Weighted Stock Price for stocks with the supplied stockSymbol that have a trade date within the last five minutes /// Throws an exception if the supplied stockSymbol is blank /// Throws an exception if there is not a stock in the Stocks StockCollection which matches the supplied stockSymbol /// </summary> /// <param name="stockSymbol"></param> /// <returns></returns> public decimal GetVolumeWeightedStockPrice(string stockSymbol) { try { if (String.IsNullOrWhiteSpace(stockSymbol)) { throw new Exception(StockSymbolHasNotBeenProvided); } if (!Stocks.StockExists(stockSymbol)) { throw new Exception(StockDoesNotExistInStockList); } var tradeRange = Trades.Where(t => t.StockSymbol == stockSymbol && t.TradeDate >= DateTime.Now.AddMinutes(-5)); if (tradeRange.Count() == 0) { return(0m); } var denominator = 0m; var numerator = 0m; foreach (var trade in tradeRange) { denominator += trade.Price * trade.Quantity; numerator += trade.Quantity; } var volumeWeightedStockPrice = denominator / numerator; return(volumeWeightedStockPrice); } catch (DivideByZeroException) { return(0); } catch (Exception ex) { throw new Exception("Exception in TradeLedger.GetVolumeWeightedStockPrice", ex); } }
public decimal GetBalance(DateTime?dateTimeUtc = null) { var depositWithdrawTotal = DepositsWithdrawals .Where(x => dateTimeUtc == null || x.Time <= dateTimeUtc) .Sum(x => x.Amount); if (dateTimeUtc == null) { return(Trades.Where(x => x.NetProfitLoss != null).Sum(x => x.NetProfitLoss.Value) + depositWithdrawTotal); } var openTradesTotal = Trades .Where(x => x.EntryDateTime != null && x.CloseDateTime == null && x.NetProfitLoss != null) .Sum(x => x.NetProfitLoss.Value); var closedTradesTotal = Trades .Where(x => x.CloseDateTime != null && x.NetProfitLoss != null && x.CloseDateTime.Value <= dateTimeUtc) .Sum(x => x.NetProfitLoss.Value); return(depositWithdrawTotal + openTradesTotal + closedTradesTotal); }
public Task SaveTradeAsync(Trade trade) { var items = Trades.Where(x => x.Id == trade.Id).ToList(); if (items.Count > 0) { foreach (var item in items) { Trades.Remove(item); } Trades.Add(trade); } else { Trades.Add(trade); } return(Task.FromResult(true)); }
public Task <List <Trade> > GetActiveTradesAsync() { return(Task.FromResult(Trades.Where(x => x.IsOpen).ToList())); }
public List <Trade> GetTradesOfVereniging(Vereniging v) { return(Trades.Where(t => (t.From.GroepId == v.GroepId || t.To.GroepId == v.GroepId)).ToList()); }
public IEnumerable <Trade> TradesApproved(int?count = null) { return(Trades.Where(c => !c.IsOffer && !c.IsOrder).OrderByDescending(c => c.DateBegin).ThenByDescending(c => c.Id).ToList().Where(c => c.IsFinallyApproved.Value).Take(count ?? Trades.Count())); }
/// <summary> /// Find the Transaction that matches this element. /// </summary> /// <param name="lpOrderId"></param> /// <returns></returns> internal Transaction FindTrade(string lpOrderId) { var trade = Trades.Where(i => i.LpOrderId.Equals(lpOrderId)).FirstOrDefault(); return(trade); }
public async Task <IRequest <IEnumerable <ITrade> > > GetLastTradesAsync(DateTime fromTime) { return(new MarketRequest <IEnumerable <ITrade> >(RequestStatus.Completed, Trades.Where(t => t.Time >= fromTime).ToList())); }
public IReadOnlyList <Trade> GetTrades(Stock stock) { return(Trades.Where(x => x.Stock.Equals(stock)).ToList().AsReadOnly()); }
/// <summary> /// Update the logger - you can call this periodically if you don't want to call Start to run the logger in a background thread. /// </summary> public async Task UpdateAsync() { ExchangeTrade[] newTrades; HashSet <string> tmpTradeIds; try { if (MarketSymbol == "*") { // get all symbols Tickers = (await API.GetTickersAsync()).ToArray(); tickerWriter.Write(Tickers.Count); foreach (KeyValuePair <string, ExchangeTicker> ticker in Tickers) { tickerWriter.Write(ticker.Key); ticker.Value.ToBinary(tickerWriter); } } else { // make API calls first, if they fail we will try again later Tickers = new KeyValuePair <string, ExchangeTicker>[1] { new KeyValuePair <string, ExchangeTicker>(MarketSymbol, await API.GetTickerAsync(MarketSymbol)) }; OrderBook = await API.GetOrderBookAsync(MarketSymbol); Trades = (await API.GetRecentTradesAsync(MarketSymbol)).OrderBy(t => t.Timestamp).ToArray(); // all API calls succeeded, we can write to files // write system date / time sysTimeWriter.Write(CryptoUtility.UtcNow.Ticks); // write ticker Tickers.First().Value.ToBinary(tickerWriter); // write order book OrderBook.ToBinary(bookWriter); // new trades only newTrades = Trades.Where(t => !tradeIds.Contains(t.Id)).ToArray(); // write new trades tradeWriter.Write(newTrades.Length); foreach (ExchangeTrade trade in newTrades) { trade.ToBinary(tradeWriter); } // track trade ids for the latest set of trades foreach (ExchangeTrade trade in Trades) { tradeIds2.Add(trade.Id); } tmpTradeIds = tradeIds; tradeIds = tradeIds2; tradeIds2 = tmpTradeIds; tradeIds2.Clear(); } DataAvailable?.Invoke(this); } catch (Exception ex) { Error?.Invoke(this, ex); } }
public MainViewModel() { Events = new ObservableCollection <string>(); _authService = ApiServiceBuilder <IUserService> .Build(TradeServiceReferential.ServiceHost) .Create(); _userToken = _authService.Login(new Credentials() { Username = "******", Password = "******" }).Result; AppCore.Instance.ObjectProvider.Configure(config => config.For <TradeServiceToken>().Use(_userToken)); _tradeService = ApiServiceBuilder <ITradeService> .Build(TradeServiceReferential.ServiceHost) .AddAuthorizationHeader(() => _userToken.Digest) .Create(); _priceEventService = SignalRServiceBuilder <Price, PriceRequest> .Create() .Build(new PriceRequest((p) => true), (opts) => { opts.AccessTokenProvider = () => Task.FromResult(_userToken.Digest); }); _priceEventService .Connect(Scheduler.Default, 1000) .Subscribe((priceEvent) => { foreach (var trade in Trades.Where(trade => trade.Asset == priceEvent.Asset).ToList()) { Application.Current.Dispatcher.Invoke(() => trade.CurrentPrice = priceEvent.Value); } var ev = MakeEvent("PRICE", "PRICE", priceEvent.Asset, priceEvent.Value); this.Notify(ev); }); _tradeEventService = SignalRServiceBuilder <TradeEvent, TradeEventRequest> .Create() .Build(new TradeEventRequest((p) => true), (opts) => { opts.AccessTokenProvider = () => Task.FromResult(_userToken.Digest); }); _tradeEventService .Connect(Scheduler.Default, 500) .Subscribe((tradeEvent) => { Application.Current.Dispatcher.Invoke(() => { var trade = Trades.FirstOrDefault(t => t.Id == tradeEvent.TradeId); if (null == trade) { return; } trade.Status = tradeEvent.Status; }); this.Notify(MakeEvent("TRADE", _tradeEventService.Current.Endpoint, tradeEvent.TradeId, tradeEvent.Status)); }); Trades = new ObservableCollection <TradeViewModel>(); MakeTrade = new Command(async() => { var asset = TradeServiceReferential.Assets.Random(); var counterparty = TradeServiceReferential.Counterparties.Random(); var rand = new Random(); var request = new TradeCreationRequest() { Counterparty = counterparty, Asset = asset.Name, Price = asset.Price, Volume = rand.Next(1, 50), Way = TradeWay.Buy }; var tradeEvent = await _tradeService.CreateTrade(request); var trade = await _tradeService.GetTradeById(tradeEvent.TradeId); Application.Current.Dispatcher.Invoke(() => Trades.Add(new TradeViewModel(trade))); }); Application.Current.Dispatcher.Invoke(async() => { var trades = await _tradeService.GetAllTrades(); foreach (var trade in trades) { var vm = new TradeViewModel(trade); Trades.Add(vm); } }); }