/// <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);
}
});
}
