private void OnQuotesReceivedEventHandler(object sender, QuotesEventArgs args)
{
Log.Verbose("Quotes: {@quotes}", args.Quotes);
MarketDataRepository.ApplyQuotes(args.Quotes);
var symbolsIds = new HashSet <int>();
foreach (var quote in args.Quotes)
{
if (!symbolsIds.Contains(quote.SymbolId))
{
symbolsIds.Add(quote.SymbolId);
}
}
foreach (var symbolId in symbolsIds)
{
var symbol = Account.Symbols.FirstOrDefault(s => s.Id == symbolId);
if (symbol != null)
{
QuotesUpdated?.Invoke(this, new MarketDataEventArgs(symbol));
}
}
}
/// <summary>
/// Loads quote summaries for the subscription
/// </summary>
public async void LoadQuoteSummariesAsync()
{
BusyMessage = Resources.LoadingQuoteSummariesMessage;
// get the data service url
var url = new Uri(ConfigurationManager.AppSettings["DataServiceUrl"]);
// create repository
var repository = new MarketDataRepository(url);
// build url to query
var queryUrl = string.Format("GetQuoteSummaries?subscriptionId={0}", Subscription.ID);
// get quote summaries
var quoteSummaries =
await Task.Factory.StartNew(() =>
repository.Execute <SubscriptionQuoteSummary>(new Uri(queryUrl, UriKind.Relative), "GET", false));
// set quote summaries
Application.Current.Dispatcher.Invoke(() =>
{
// set quote summaries
QuoteSummaries = new ObservableCollection <SubscriptionQuoteSummary>(quoteSummaries);
// clear busy message
BusyMessage = null;
});
}
private void OnSnapshotReceivedEventHandler(
object sender,
SnapshotEventArgs args)
{
Log.Verbose("Snapshot: {@snapshot}", args.Snapshot);
MarketDataRepository.ApplySnapshot(args.Snapshot);
}
public void MarketData_CanLoad()
{
IMarketDataRepository marketDataRepo = new MarketDataRepository(@"market.csv");
var market = marketDataRepo.GetMarketData();
Assert.AreEqual(7, market.Count());
}
static void Main(string[] args)
{
int exitCode = 0;
int loanAmount = 0;
try
{
if (args.Length < 2)
{
Console.WriteLine("Not enough parameters - expected [market_file] [loan_amount]");
}
else if (!int.TryParse(args[1], out loanAmount))
{
Console.WriteLine("Loan Amount must be a valid integer");
}
else
{
var marketData = args[0];
if (!int.TryParse(args[1], out loanAmount))
{
Console.WriteLine("Loan Amount must be a valid integer");
}
IMarketCalculator marketCalculator = new MarketCalculator();
IMarketDataRepository marketDataRepository = new MarketDataRepository(marketData);
IQuoteCalculator quoteCalculator = new QuoteCalculator(marketDataRepository, marketCalculator);
IQuoteResultFormatter resultFormatter = new QuoteResultFormatter();
var quoteResult = quoteCalculator.GetQuote(loanAmount);
Console.WriteLine(resultFormatter.Format(quoteResult));
}
}
catch (Exception exception)
{
Console.WriteLine("Oops! an error occured retrieving your quote");
Console.WriteLine(exception.Message);
exitCode = 1;
}
Console.ReadKey();
Environment.Exit(exitCode);
}
/// <summary>
/// Asynchronously loads subscriptions
/// </summary>
public async void LoadAsync()
{
// set busy message
BusyMessage = Resources.LoadingSubscriptionsMessage;
// get the data service url
var url = new Uri(ConfigurationManager.AppSettings["DataServiceUrl"]);
// create repository
var repository = new MarketDataRepository(url);
// create collection into which to load data
IEnumerable <DataProvider> dataProviders = null;
IEnumerable <StockListProvider> stockListProviders = null;
IEnumerable <Subscription> subscriptions = null;
// load data async
await Task.Factory.StartNew(() =>
{
dataProviders = repository.DataProviders.Execute();
stockListProviders = repository.StockListProviders.Execute();
subscriptions = repository.Subscriptions.Expand("DataProvider, StockListProvider").Execute();
});
Application.Current.Dispatcher.Invoke(() =>
{
// set subscriptions
DataProviders = new ObservableCollection <DataProvider>(dataProviders);
StockListProviders = new ObservableCollection <StockListProvider>(stockListProviders);
Subscriptions = new ObservableCollection <SubscriptionViewModel>(subscriptions.Select(s => new SubscriptionViewModel(s)));
// clear busy message
BusyMessage = string.Empty;
});
}
private void OnEntriesReceivedEventHandler(object sender, EntriesEventArgs args)
{
Log.Verbose("Entries: {@entries}", args.Entries);
MarketDataRepository.ApplyEntries(args.Entries);
}
public Quote GetQuote(Symbol symbol)
{
return(MarketDataRepository?.QuoteBySymbolId(symbol.Id));
}
public MarketDataOrderBook GetOrderBook(Symbol symbol)
{
return(MarketDataRepository?.OrderBookBySymbolId(symbol.Id));
}
public async Task StartAsync()
{
Log.Information("Start terminal services");
var configuration = Configuration.GetSection($"Services:{Account.Network}");
// init schemes
Schemes = new ProtoSchemes(
currencies: Account.Currencies,
symbols: Account.Symbols);
// init market data repository
MarketDataRepository = new MarketDataRepository(Account.Symbols);
// init exchange client
ExchangeClient = new ExchangeWebClient(configuration, Schemes);
ExchangeClient.Connected += OnExchangeConnectedEventHandler;
ExchangeClient.Disconnected += OnExchangeDisconnectedEventHandler;
ExchangeClient.AuthOk += OnExchangeAuthOkEventHandler;
ExchangeClient.AuthNonce += OnExchangeAuthNonceEventHandler;
ExchangeClient.Error += OnExchangeErrorEventHandler;
ExchangeClient.OrderReceived += OnExchangeOrderEventHandler;
ExchangeClient.SwapReceived += OnSwapReceivedEventHandler;
// init market data client
MarketDataClient = new MarketDataWebClient(configuration, Schemes);
MarketDataClient.Connected += OnMarketDataConnectedEventHandler;
MarketDataClient.Disconnected += OnMarketDataDisconnectedEventHandler;
MarketDataClient.AuthOk += OnMarketDataAuthOkEventHandler;
MarketDataClient.AuthNonce += OnMarketDataAuthNonceEventHandler;
MarketDataClient.Error += OnMarketDataErrorEventHandler;
MarketDataClient.QuotesReceived += OnQuotesReceivedEventHandler;
MarketDataClient.EntriesReceived += OnEntriesReceivedEventHandler;
MarketDataClient.SnapshotReceived += OnSnapshotReceivedEventHandler;
// init swap manager
SwapManager = new ClientSwapManager(
account: Account,
swapClient: ExchangeClient,
taskPerformer: TaskPerformer);
SwapManager.SwapUpdated += (sender, args) => SwapUpdated?.Invoke(sender, args);
// run services
await Task.WhenAll(
ExchangeClient.ConnectAsync(),
MarketDataClient.ConnectAsync())
.ConfigureAwait(false);
// run tracker
TaskPerformer.EnqueueTask(new BalanceUpdateTask
{
Account = Account,
Interval = TimeSpan.FromSeconds(Account.UserSettings.BalanceUpdateIntervalInSec)
});
TaskPerformer.Start();
// start to track unconfirmed transactions
await TrackUnconfirmedTransactionsAsync()
.ConfigureAwait(false);
// restore swaps
SwapManager.RestoreSwapsAsync().FireAndForget();
}
public void MarketData_FileNotFound()
{
IMarketDataRepository marketDataRepo = new MarketDataRepository(@"missingfile.csv");
var market = marketDataRepo.GetMarketData();
}
public void MarketData_NoFileSpecified()
{
IMarketDataRepository marketDataRepo = new MarketDataRepository(null);
}
