public TradesByTimeViewer(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
_schedulerProvider = schedulerProvider;
var groupController = new GroupController();
var grouperRefresher = Observable.Interval(TimeSpan.FromSeconds(1))
.Subscribe(_ => groupController.RefreshGroup());
var loader = tradeService.Trades.Connect()
.Group(trade =>
{
var diff = DateTime.Now.Subtract(trade.Timestamp);
if (diff.TotalSeconds <= 60) return TimePeriod.LastMinute;
if (diff.TotalMinutes <= 60) return TimePeriod.LastHour;
return TimePeriod.Older;
}, groupController)
.Transform(group => new TradesByTime(group, _schedulerProvider))
.Sort(SortExpressionComparer<TradesByTime>.Ascending(t => t.Period))
.ObserveOn(_schedulerProvider.Dispatcher)
.Bind(_data)
.DisposeMany()
.Subscribe();
_cleanUp = new CompositeDisposable(loader, grouperRefresher);
}
public TradePriceUpdateJob(ITradeService tradeService, IMarketPriceService marketPriceService)
{
_job = tradeService.Trades.Connect()
.Filter(trade => trade.Status == TradeStatus.Live)
.Group(trade => trade.CurrencyPair)
.SubscribeMany(groupedData =>
{
var locker = new object();
decimal latestPrice = 0;
//subscribe to price and update trades with the latest price
var priceHasChanged = marketPriceService.ObservePrice(groupedData.Key)
.Synchronize(locker)
.Subscribe(price =>
{
latestPrice = price;
UpdateTradesWithPrice(groupedData.Cache.Items, latestPrice);
});
//connect to data changes and update with the latest price
var dataHasChanged = groupedData.Cache.Connect()
.WhereReasonsAre(ChangeReason.Add, ChangeReason.Update)
.Synchronize(locker)
.Subscribe(changes => UpdateTradesWithPrice(changes.Select(change => change.Current), latestPrice));
return new CompositeDisposable(priceHasChanged, dataHasChanged);
})
.Subscribe();
}
private void SetMainService(ITradeService service)
{
foreach (var kv in _services)
{
_services[kv.Key] = kv.Key.GetType().Name == service.GetType().Name;
}
}
private static ApiResult InvokeApi(ITradeService service, MainAccount account, string methodName, object[] arguments)
{
var host = ManagerCore.Instance.ApiHostManager.GetFastHost(service.GetType());
service.Account = account;
service.Host = host;
service.Login();
var method = service.GetType().GetMethod(methodName);
if (method == null)
{
throw new Exception("没有找到接口" + methodName);
}
var result = (ApiResult)method.Invoke(service, arguments);
if (!string.IsNullOrEmpty(result.Error))
{
//尝试一次登录
if (result.Error.Contains("连接已断开"))
{
service.Logout();
service.Login();
result = (ApiResult)method.Invoke(service, arguments);
}
}
return result;
}
public PagedDataViewer(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
//build observable predicate from search text
var filter = this.WhenValueChanged(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter);
//build observable sort comparer
var sort = SortParameters.WhenValueChanged(t => t.SelectedItem)
.Select(prop => prop.Comparer)
.ObserveOn(schedulerProvider.TaskPool);
//build observable comparer
var currentPageChanged = PageParameters.WhenValueChanged(p => p.CurrentPage);
var pageSizeChanged = PageParameters.WhenValueChanged(p => p.PageSize);
var pager = currentPageChanged.CombineLatest(pageSizeChanged,(page, size) => new PageRequest(page, size))
.StartWith(new PageRequest(1, 25))
.DistinctUntilChanged()
.Sample(TimeSpan.FromMilliseconds(100));
// filter, sort, page and bind to observable collection
_cleanUp = tradeService.All.Connect()
.Filter(filter) // apply user filter
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(sort, SortOptimisations.ComparesImmutableValuesOnly)
.Page(pager)
.ObserveOn(schedulerProvider.MainThread)
.Do(changes => _pageParameters.Update(changes.Response))
.Bind(out _data) // update observable collection bindings
.DisposeMany() // dispose when no longer required
.Subscribe();
}
public SearchHints(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
//instaniate a filter controller so we can change the filter any time
var filter = new FilterController<string>();
//build a predicate when SeatchText changes
var filterApplier = this.WhenValueChanged(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter)
.Subscribe(filter.Change);
//share the connection
var shared = tradeService.All.Connect().Publish();
//distinct list of customers
var customers = shared.DistinctValues(trade => trade.Customer);
//distinct list of currency pairs
var currencypairs = shared.DistinctValues(trade => trade.CurrencyPair);
//create single list of all customers all items in currency ypairs
var loader = customers.Or(currencypairs)
.Filter(filter) //filter strings
.Sort(SortExpressionComparer<string>.Ascending(str=>str))
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _hints) //bind to hints list
.Subscribe();
_cleanUp = new CompositeDisposable(loader, filter, shared.Connect(), filterApplier);
}
public AnalysisService(
IQuoteService quoteService,
ITradeService tradeService,
IAppSettingsService configs
)
{
_quoteService = quoteService;
_tradeService = tradeService;
_configs = configs;
}
public PositionsViewer(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
_cleanUp = tradeService.Live.Connect()
.Group(trade => trade.CurrencyPair)
.Transform(group => new CurrencyPairPosition(group))
.Sort(SortExpressionComparer<CurrencyPairPosition>.Ascending(t => t.CurrencyPair))
.ObserveOn(schedulerProvider.MainThread)
.Bind(_data)
.DisposeMany()
.Subscribe();
}
public RecentTradesViewer(ILogger logger, ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
_logger = logger;
_cleanUp = tradeService.All.Connect()
.SkipInitial()
.ExpireAfter((trade) => TimeSpan.FromSeconds(30))
.Transform(trade => new TradeProxy(trade))
.Sort(SortExpressionComparer<TradeProxy>.Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
}
public RxUiViewer(ITradeService tradeService)
{
//Change the filter when the user entered search text changes
var filter = this.WhenAnyValue(x => x.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter);
_cleanUp = tradeService.All
.Connect(trade => trade.Status == TradeStatus.Live) //prefilter live trades only
.Filter(filter) // apply user filter
//if targetting Net4 or Net45 platform can use parallelisation for transforms 'cause it's quicker
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(SortExpressionComparer<TradeProxy>.Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(_data) //bind the results to the ReactiveList
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
}
static void Main(string[] args)
{
container = new UnityContainer();
ContainerBootStrapper.RegisterTypes(container); // Register Unity Container for services use dependency injection
try
{
_stockService = container.Resolve <IStockService>("MockedStockService"); // Using Mocked Stock service as all data is mocked and not loaded from DB.
// Production code will use StockService insted of Mocked Service --Not implemented
_tradeService = new TradeService();
SetupPrice(); // Setting up market price
SetupTrades(); //setting up trades
PrintOutput(); //printing output
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + " \n Please try again");
}
Console.ReadKey();
}
public LiveTradesViewer(ITradeService tradeService, SearchHints searchHints)
{
SearchHints = searchHints;
var filter = SearchHints.WhenValueChanged(t => t.SearchText)
.Select(BuildFilter);
var loader = tradeService.Live.Connect()
.BatchIf(this.WhenValueChanged(x => x.Paused), null, null) //I need to fix the API, so nulls do not have to be passed in
.Filter(filter) // apply user filter
.Transform(trade => new TradeProxy(trade))
.Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly, 25)
.ObserveOnDispatcher()
.Bind(out _data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, searchHints);
}
public LiveTradesViewer(ITradeService tradeService, SearchHints searchHints)
{
_searchHints = searchHints;
var filter = SearchHints.WhenValueChanged(t => t.SearchText)
.Select(BuildFilter);
var loader = tradeService.Live.Connect()
.Filter(filter) // apply user filter
//if targeting dotnet 4.5 can parallelise 'cause it's quicker
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOnDispatcher()
.Bind(out _data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, searchHints);
}
public MarketMakerService(
IInstrumentService instrumentService,
ILykkeExchangeService lykkeExchangeService,
IOrderBookService orderBookService,
IBalanceService balanceService,
IMarketMakerStateService marketMakerStateService,
IQuoteService quoteService,
IB2C2OrderBookService b2C2OrderBookService,
IQuoteTimeoutSettingsService quoteTimeoutSettingsService,
ISummaryReportService summaryReportService,
IPositionService positionService,
IAssetsServiceWithCache assetsServiceWithCache,
IMarketMakerSettingsService marketMakerSettingsService,
ITradeService tradeService,
IAssetPairLinkService assetPairLinkService,
IPnLStopLossEngineService pnLStopLossEngineService,
IFiatEquityStopLossService fiatEquityStopLossService,
INoFreshQuotesStopLossService noFreshQuotesStopLossService,
IOrderBooksUpdatesReportPublisher orderBooksUpdatesReportPublisher,
bool isOrderBooksUpdateReportEnabled,
ILogFactory logFactory)
{
_instrumentService = instrumentService;
_lykkeExchangeService = lykkeExchangeService;
_orderBookService = orderBookService;
_balanceService = balanceService;
_marketMakerStateService = marketMakerStateService;
_quoteService = quoteService;
_b2C2OrderBookService = b2C2OrderBookService;
_quoteTimeoutSettingsService = quoteTimeoutSettingsService;
_summaryReportService = summaryReportService;
_positionService = positionService;
_assetsServiceWithCache = assetsServiceWithCache;
_marketMakerSettingsService = marketMakerSettingsService;
_tradeService = tradeService;
_assetPairLinkService = assetPairLinkService;
_pnLStopLossEngineService = pnLStopLossEngineService;
_fiatEquityStopLossService = fiatEquityStopLossService;
_noFreshQuotesStopLossService = noFreshQuotesStopLossService;
_orderBooksUpdatesReportPublisher = orderBooksUpdatesReportPublisher;
_isOrderBooksUpdateReportEnabled = isOrderBooksUpdateReportEnabled;
_log = logFactory.CreateLog(this);
}
public static TradeResponseDTO MapTradeLogToDto(TradeLog trade, ITradeService tradeService)
{
_tradeService = tradeService;
var result = new TradeResponseDTO
{
ID = trade.TradeId,
CreatedOn = trade.TradePlaceDate,
Price = trade.Amount,
UserId = trade.TraderUid,
Arbitrage = trade.WasArbitrageSuggestion,
Social = trade.Socialtrade,
CurrencyPair = trade.CurrencyPair
};
result.Exchange = _tradeService.GetExchangeTypeById(trade.ExchangeFromTypeId.Value) + "/" + _tradeService.GetExchangeTypeById(trade.ExchangeToTypeId.Value);
result.Operation = _tradeService.GetTradeOperationById(trade.TradeTypeId.Value);
return(result);
}
public LiveTradesViewer(ITradeService tradeService,SearchHints searchHints)
{
_searchHints = searchHints;
var filter = SearchHints.WhenValueChanged(t => t.SearchText)
.Select(BuildFilter);
var loader = tradeService.Live.Connect()
.Filter(filter) // apply user filter
//if targeting dotnet 4.5 can parallelise 'cause it's quicker
.Transform(trade => new TradeProxy(trade),new ParallelisationOptions(ParallelType.Ordered,5))
.Sort(SortExpressionComparer<TradeProxy>.Descending(t => t.Timestamp),SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOnDispatcher()
.Bind(out _data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, searchHints);
}
public RxUiViewModel(ITradeService tradeService)
{
//Change the filter when the user entered search text changes
var filter = this.WhenAnyValue(x => x.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter);
_cleanUp = tradeService.Live.Connect()
.Filter(filter) // apply user filter
//if targetting Net4 or Net45 platform can use parallelisation for transforms 'cause it's quicker
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly, 25)
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(_data) //bind the results to the ReactiveList
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe(_ =>
{
});
}
public StartupManager(
LykkeBalancesTimer lykkeBalancesTimer,
ExternalBalancesTimer externalBalancesTimer,
MarketMakerTimer marketMakerTimer,
HedgingTimer hedgingTimer,
SettlementsTimer settlementsTimer,
InternalTraderTimer internalTraderTimer,
PnLStopLossEngineTimer pnLStopLossEngineTimer,
LykkeTradeSubscriber lykkeTradeSubscriber,
B2C2QuoteSubscriber b2C2QuoteSubscriber,
B2C2OrderBooksSubscriber b2C2OrderBooksSubscriber,
QuoteSubscriber[] quoteSubscribers,
OrderBooksUpdatesReportSubscriber orderBooksUpdatesReportSubscriber,
InternalQuotePublisher internalQuotePublisher,
InternalOrderBookPublisher internalOrderBookPublisher,
OrderBooksUpdatesReportPublisher orderBooksUpdatesReportPublisher,
LykkeTradeSubscriberMonitor lykkeTradeSubscriberMonitor,
StorageMigrationService storageMigrationService,
ITradeService tradeService,
IHedgeService hedgeService,
IMarketMakerService marketMakerService)
{
_lykkeBalancesTimer = lykkeBalancesTimer;
_externalBalancesTimer = externalBalancesTimer;
_marketMakerTimer = marketMakerTimer;
_hedgingTimer = hedgingTimer;
_settlementsTimer = settlementsTimer;
_internalTraderTimer = internalTraderTimer;
_pnLStopLossEngineTimer = pnLStopLossEngineTimer;
_lykkeTradeSubscriber = lykkeTradeSubscriber;
_b2C2QuoteSubscriber = b2C2QuoteSubscriber;
_b2C2OrderBooksSubscriber = b2C2OrderBooksSubscriber;
_quoteSubscribers = quoteSubscribers;
_orderBooksUpdatesReportSubscriber = orderBooksUpdatesReportSubscriber;
_internalQuotePublisher = internalQuotePublisher;
_internalOrderBookPublisher = internalOrderBookPublisher;
_orderBooksUpdatesReportPublisher = orderBooksUpdatesReportPublisher;
_lykkeTradeSubscriberMonitor = lykkeTradeSubscriberMonitor;
_storageMigrationService = storageMigrationService;
_tradeService = tradeService;
_hedgeService = hedgeService;
_marketMakerService = marketMakerService;
}
public PagedDataViewer(ILogger logger, ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
_logger = logger;
//watch for filter changes and change filter
var filterController = new FilterController <Trade>(trade => true);
var filterApplier = this.ObservePropertyValue(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(propargs => BuildFilter(propargs.Value))
.Subscribe(filterController.Change);
//watch for changes to sort and apply when necessary
var sortContoller = new SortController <TradeProxy>(SortExpressionComparer <TradeProxy> .Ascending(proxy => proxy.Id));
var sortChange = SortParameters.ObservePropertyValue(t => t.SelectedItem).Select(prop => prop.Value.Comparer)
.ObserveOn(schedulerProvider.TaskPool)
.Subscribe(sortContoller.Change);
//watch for page changes and change filter
var pageController = new PageController();
var currentPageChanged = PageParameters.ObservePropertyValue(p => p.CurrentPage).Select(prop => prop.Value);
var pageSizeChanged = PageParameters.ObservePropertyValue(p => p.PageSize).Select(prop => prop.Value);
var pageChanger = currentPageChanged.CombineLatest(pageSizeChanged,
(page, size) => new PageRequest(page, size))
.DistinctUntilChanged()
.Sample(TimeSpan.FromMilliseconds(100))
.Subscribe(pageController.Change);
// filter, sort, page and bind to loaded data
var loader = tradeService.All.Connect()
.Filter(filterController) // apply user filter
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(sortContoller, SortOptimisations.ComparesImmutableValuesOnly)
.Page(pageController)
.ObserveOn(schedulerProvider.MainThread)
.Do(changes => _pageParameters.Update(changes.Response))
.Bind(_data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, filterController, filterApplier, sortChange, sortContoller, pageChanger, pageController);
}
public LiveTradesViewer(ILogger logger,ITradeService tradeService)
{
_logger = logger;
var filterApplier = this.ObserveChanges()
.Throttle(TimeSpan.FromMilliseconds(250))
.Subscribe(_ => ApplyFilter());
ApplyFilter();
var loader = tradeService.Trades
.Connect(trade => trade.Status == TradeStatus.Live) //prefilter live trades only
.Filter(_filter) // apply user filter
.Transform(trade => new TradeProxy(trade),new ParallelisationOptions(ParallelType.Ordered,5))
.Sort(SortExpressionComparer<TradeProxy>.Descending(t => t.Timestamp),SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOnDispatcher()
.Bind(_data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, _filter, filterApplier);
}
public VisibleRowsViewer(ITradeService tradeService)
{
var loader = tradeService.All.Connect()
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOnDispatcher()
.Bind(out _data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
//NEED TO DO SOMETHING FUNKY
var visibilityController = _visibleRowsAccessor.VisibleRows.Connect()
.SubscribeMany(proxy =>
{
//
return(proxy.WhenValueChanged(p => p.Amount).Subscribe());
}).Subscribe();
_cleanUp = new CompositeDisposable(loader, _visibleRowsAccessor, visibilityController);
}
public PositionService(
[KeyFilter("PositionRepositoryAzure")] IPositionRepository positionRepository,
[KeyFilter("PositionRepositoryPostgres")] IPositionRepository positionRepositoryPostgres,
IOpenPositionRepository openPositionRepository,
ISummaryReportService summaryReportService,
IInstrumentService instrumentService,
IQuoteService quoteService,
ITradeService tradeService,
IClosedPositionHandler[] closedPositionHandlers,
ILogFactory logFactory)
{
_positionRepository = positionRepository;
_positionRepositoryPostgres = positionRepositoryPostgres;
_openPositionRepository = openPositionRepository;
_summaryReportService = summaryReportService;
_instrumentService = instrumentService;
_quoteService = quoteService;
_tradeService = tradeService;
_closedPositionHandlers = closedPositionHandlers;
_log = logFactory.CreateLog(this);
}
public LiveTradesViewer(ILogger logger, ITradeService tradeService)
{
_logger = logger;
var filterApplier = this.ObserveChanges()
.Throttle(TimeSpan.FromMilliseconds(250))
.Subscribe(_ => ApplyFilter());
var loader = tradeService.All
.Connect(trade => trade.Status == TradeStatus.Live) //prefilter live trades only
.Filter(_filter) // apply user filter
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOnDispatcher()
.Bind(_data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, _filter, filterApplier);
}
public PagedDataViewer(ILogger logger, ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
_logger = logger;
//watch for filter changes and change filter
var filterController = new FilterController<Trade>(trade => true);
var filterApplier = this.ObservePropertyValue(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(propargs => BuildFilter(propargs.Value))
.Subscribe(filterController.Change);
//watch for changes to sort and apply when necessary
var sortContoller = new SortController<TradeProxy>(SortExpressionComparer<TradeProxy>.Ascending(proxy=>proxy.Id));
var sortChange = SortParameters.ObservePropertyValue(t => t.SelectedItem).Select(prop=>prop.Value.Comparer)
.ObserveOn(schedulerProvider.TaskPool)
.Subscribe(sortContoller.Change);
//watch for page changes and change filter
var pageController = new PageController();
var currentPageChanged = PageParameters.ObservePropertyValue(p => p.CurrentPage).Select(prop => prop.Value);
var pageSizeChanged = PageParameters.ObservePropertyValue(p => p.PageSize).Select(prop => prop.Value);
var pageChanger = currentPageChanged.CombineLatest(pageSizeChanged,(page, size) => new PageRequest(page, size))
.DistinctUntilChanged()
.Sample(TimeSpan.FromMilliseconds(100))
.Subscribe(pageController.Change);
// filter, sort, page and bind to loaded data
var loader = tradeService.All .Connect()
.Filter(filterController) // apply user filter
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(sortContoller, SortOptimisations.ComparesImmutableValuesOnly)
.Page(pageController)
.ObserveOn(schedulerProvider.MainThread)
.Do(changes => _pageParameters.Update(changes.Response))
.Bind(_data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, filterController, filterApplier, sortChange,sortContoller, pageChanger, pageController);
}
public RecentTradesViewer(ILogger logger, ITradeService tradeService)
{
_logger = logger;
var filterApplier = this.ObserveChanges()
.Sample(TimeSpan.FromMilliseconds(250))
.Subscribe(_ => ApplyFilter());
ApplyFilter();
var loader = tradeService.Trades.Connect()
.SkipInitial()
.AutoRemove((trade) => TimeSpan.FromSeconds(30))
.Transform(trade => new TradeProxy(trade))
.Sort(SortExpressionComparer<TradeProxy>.Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOnDispatcher()
.Bind(_data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, _filter, filterApplier);
}
public VisibleRowsViewer(ITradeService tradeService, ILogger logger)
{
var loader = tradeService.All.Connect()
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(SortExpressionComparer<TradeProxy>.Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOnDispatcher()
.Bind(out _data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
//NEED TO DO SOMETHING FUNKY
var visibilityController = _visibleRowsAccessor.VisibleRows.Connect()
.SubscribeMany(proxy =>
{
//
return proxy.WhenValueChanged(p => p.Amount).Subscribe();
}).Subscribe();
_cleanUp = new CompositeDisposable(loader, _visibleRowsAccessor, visibilityController);
}
public RecentTradesViewer(ILogger logger, ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
_logger = logger;
var filterApplier = this.ObserveChanges()
.Sample(TimeSpan.FromMilliseconds(250))
.Subscribe(_ => ApplyFilter());
ApplyFilter();
var loader = tradeService.All.Connect()
.SkipInitial()
.ExpireAfter((trade) => TimeSpan.FromSeconds(30))
.Transform(trade => new TradeProxy(trade))
.Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOn(schedulerProvider.MainThread)
.Bind(_data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, _filter, filterApplier);
}
public PagedDataViewer(ITradeService tradeService, SearchHints searchHints)
{
SearchHints = searchHints;
SortParameters = new SortParameterData(
tradeService.Live
.Selecting(t => new TradeProxy(t))
.CollectionDisposing(),
_consumer);
AllData =
new Computing <ObservableCollection <TradeProxy> >(
() => SortParameters.SelectedItem.SortedData)
.Filtering(t =>
t.Trade.CurrencyPair.Contains(SearchHints.SearchTextThrottled.Value, StringComparison.OrdinalIgnoreCase) ||
t.Trade.Customer.Contains(SearchHints.SearchTextThrottled.Value, StringComparison.OrdinalIgnoreCase));
Data = AllData.Paging(25, 1).For(_consumer);
_nextPageCommand = new Command(() => Data.CurrentPage = Data.CurrentPage + 1, () => Data.CurrentPage < Data.PageCount);
_previousPageCommand = new Command(() => Data.CurrentPage = Data.CurrentPage - 1, () => Data.CurrentPage > 1);
}
public StockManagementService(IStockRepository stockRepo, ITradeService tradeService)
{
if (stockRepo == null)
{
throw new ArgumentNullException("stockRepo");
}
if (tradeService == null)
{
throw new ArgumentNullException("tradeService");
}
this.stockRepo = stockRepo;
this.tradeService = tradeService;
this.Stocks = new Dictionary <String, IStock>();
// Populate all the stocks into our dictionary
foreach (IStock stock in stockRepo.GetAllStocks())
{
this.Stocks.Add(stock.Symbol, stock);
}
}
static void SetUpData()
{
log.Info("Inside SetUpData");
var stocks = new List <Stock>(5)
{
new Stock {
Symbol = "TEA", StockType = StockType.Common, LastDividend = 0, ParValue = 100
},
new Stock {
Symbol = "POP", StockType = StockType.Common, LastDividend = 8, ParValue = 100
},
new Stock {
Symbol = "ALE", StockType = StockType.Common, LastDividend = 23, ParValue = 60
},
new Stock {
Symbol = "GIN", StockType = StockType.Preferred, LastDividend = 8, FixedDividend = 2, ParValue = 100
},
new Stock {
Symbol = "JOE", StockType = StockType.Common, LastDividend = 13, ParValue = 250
}
};
var trades = new List <Trade>(5)
{
new Trade(new Stock {
Symbol = "TEA", StockType = StockType.Common, LastDividend = 0, ParValue = 100
}, 100, 50),
new Trade(new Stock {
Symbol = "POP", StockType = StockType.Common, LastDividend = 8, ParValue = 100
}, 50, 20),
};
_stockService = new StockService(stocks);
_tradeService = new TradeService(trades);
log.Info("SetUpData Complete");
}
public SearchHints(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
//build a predicate when SearchText changes
var filter = this.WhenValueChanged(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter);
//share the connection
var shared = tradeService.All.Connect().Publish();
//distinct observable of customers
var customers = shared.DistinctValues(trade => trade.Customer);
//distinct observable of currency pairs
var currencypairs = shared.DistinctValues(trade => trade.CurrencyPair);
//observe customers and currency pairs using OR operator, and bind to the observable collection
var loader = customers.Or(currencypairs)
.Filter(filter) //filter strings
.Sort(SortExpressionComparer <string> .Ascending(str => str))
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _hints) //bind to hints list
.Subscribe();
_cleanUp = new CompositeDisposable(loader, shared.Connect());
}
public TradeAgeUpdateJob(OcDispatcher backgroundOcDispatcher, ITradeService tradeService)
{
_recurringAction = new RecurringAction(() =>
{
Trade[] trades = null;
backgroundOcDispatcher.Invoke(() =>
trades = tradeService.All.ToArray());
if (trades != null)
{
foreach (IEnumerable <Trade> tradesSlice in trades.Split(300))
{
backgroundOcDispatcher.Invoke(() =>
{
foreach (Trade trade in tradesSlice)
{
TimeSpan diff = DateTime.Now.Subtract(trade.Timestamp);
TimePeriod age =
diff.TotalSeconds <= 60 ? TimePeriod.LastMinute
: diff.TotalMinutes <= 60 ? TimePeriod.LastHour
: TimePeriod.Older;
trade.Age = age;
if (diff.TotalSeconds > 30)
{
trade.Expired = true;
}
}
});
}
}
}, () => TimeSpan.FromSeconds(1));
}
public LiveTradesViewer(ILogger logger, ITradeService tradeService, SearchHints searchHints)
{
_logger = logger;
_searchHints = searchHints;
var filter = new FilterController <Trade>(trade => true);
var filterApplier = SearchHints.ObservePropertyValue(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(propargs => BuildFilter(propargs.Value))
.Subscribe(filter.Change);
var loader = tradeService.All
.Connect(trade => trade.Status == TradeStatus.Live) //prefilter live trades only
.Filter(filter) // apply user filter
//if using dotnet 4.5 can parallelise 'case it's quicler
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOnDispatcher()
.Bind(_data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, filter, filterApplier, searchHints);
}
public SearchHints(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
//build a predicate when SearchText changes
var filter = this.WhenValueChanged(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter);
//share the connection
var shared = tradeService.All.Connect().Publish();
//distinct observable of customers
var customers = shared.DistinctValues(trade => trade.Customer);
//distinct observable of currency pairs
var currencypairs = shared.DistinctValues(trade => trade.CurrencyPair);
//observe customers and currency pairs using OR operator, and bind to the observable collection
var loader = customers.Or(currencypairs)
.Filter(filter) //filter strings
.Sort(SortExpressionComparer<string>.Ascending(str=>str))
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _hints) //bind to hints list
.Subscribe();
_cleanUp = new CompositeDisposable(loader, shared.Connect());
}
public LiveTradesViewer(ILogger logger,ITradeService tradeService,SearchHints searchHints)
{
_logger = logger;
_searchHints = searchHints;
var filter = new FilterController<Trade>(trade=>true);
var filterApplier = SearchHints.ObservePropertyValue(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(propargs=>BuildFilter(propargs.Value))
.Subscribe(filter.Change);
var loader = tradeService.All
.Connect(trade => trade.Status == TradeStatus.Live) //prefilter live trades only
.Filter(filter) // apply user filter
//if using dotnet 4.5 can parallelise 'case it's quicler
.Transform(trade => new TradeProxy(trade),new ParallelisationOptions(ParallelType.Ordered,5))
.Sort(SortExpressionComparer<TradeProxy>.Descending(t => t.Timestamp),SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOnDispatcher()
.Bind(_data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, filter, filterApplier, searchHints);
}
public TradesController(ITradeService tradeService)
{
_tradeService = tradeService;
}
public ConsoleApplication(ITradeService tradeService)
{
_tradeService = tradeService;
}
public TradeRepository(ILoggerFactory loggerFactory, ITradeService repository)
{
_logger = loggerFactory.CreateLogger <TradeRepository>();
_repository = repository;
}
public TradeView(ITradeService tradeService)
{
_tradeService = tradeService;
}
public TradeGateway(ITradeService tradeService, ViewModelToModelMapper viewModelToModelMapper)
{
Guard.AgainstNull(() => tradeService, () => viewModelToModelMapper);
_tradeService = tradeService;
_viewModelToModelMapper = viewModelToModelMapper;
}
public NotificationService(ITradeService tradeService, ILogger <NotificationService> logger)
{
this.tradeService = tradeService;
this.logger = logger;
}
public PortfolioService(IBaseRepo <Portfolio> repo, ITradeService tradeSvc) : base(repo)
{
this.tradeSvc = tradeSvc;
}
public MainViewModel()
{
Events = new ObservableCollection <string>();
Trades = new ObservableCollection <TradeViewModel>();
var configuration = AppCore.Instance.Get <AppConfiguration>();
var refitSettings = new RefitSettings()
{
ContentSerializer = new JsonContentSerializer(AppCore.Instance.Get <JsonSerializerSettings>()),
HttpMessageHandlerFactory = () => new HttpRetryForeverMessageHandler(5000)
};
_tradeService = ApiServiceBuilder <ITradeService> .Build(configuration.Gateway)
.AddAuthorizationHeader(() =>
{
return(_token.AccessToken);
})
.Create(refitSettings: refitSettings);
MakeTrade = new Command(async() =>
{
var asset = TradeServiceReferential.Assets.Random();
var counterparty = TradeServiceReferential.Counterparties.Random();
var rand = new Random();
var request = new TradeCreationRequest()
{
Asset = asset.Name,
Volume = rand.Next(1, 50),
Way = TradeWay.Buy
};
var tradeEvent = await _tradeService.CreateTrade(request);
var trade = await _tradeService.GetTradeById(tradeEvent.TradeId);
Notify($"{_token.User.Identity.Name} created trade {trade.EntityId} on desktop UI");
});
var options = new OidcClientOptions()
{
Authority = configuration.Identity,
ClientId = AzurePlaygroundConstants.Auth.ClientOpenIdNative,
Scope = "openid profile desk trade",
Policy = new Policy {
Discovery = new DiscoveryPolicy {
RequireHttps = false
}
},
RedirectUri = "http://127.0.0.1/sample-wpf-app",
PostLogoutRedirectUri = "http://127.0.0.1/sample-wpf-app",
ResponseMode = OidcClientOptions.AuthorizeResponseMode.FormPost,
Flow = OidcClientOptions.AuthenticationFlow.AuthorizationCode,
Browser = new WpfEmbeddedBrowser()
};
_oidcClient = new OidcClient(options);
Login = new Command(async() =>
{
try
{
_token = await _oidcClient.LoginAsync(new IdentityModel.OidcClient.LoginRequest());
}
catch (Exception ex)
{
Notify(ex.ToString());
return;
}
if (_token.IsError)
{
var error = _token.Error == "User Cancellled" ? "The sign-in window was closed before authorization was completed." : _token.Error;
Notify(error);
}
else
{
Token = _token;
Notify($"Logged in as { _token.User.Identity.Name}");
_priceEventService = SignalRServiceBuilder <Price, PriceRequest>
.Create()
.Build(new PriceRequest((p) => true), (opts) =>
{
opts.AccessTokenProvider = () => Task.FromResult(_token.AccessToken);
});
var priceServiceConnection = _priceEventService
.Connect(Scheduler.Default, 1000)
.Subscribe((priceEvent) =>
{
lock (_locker)
{
if (null == Application.Current.Dispatcher)
{
return;
}
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 <Trade, TradeEventRequest>
.Create()
.Build(new TradeEventRequest((p) => true), (opts) =>
{
opts.AccessTokenProvider = () => Task.FromResult(_token.AccessToken);
});
var tradeEventServiceConnection = _tradeEventService
.Connect(Scheduler.Default, 500)
.Subscribe((tradeEvent) =>
{
lock (_locker)
{
if (null == Application.Current.Dispatcher)
{
return;
}
Application.Current.Dispatcher.Invoke(() =>
{
var trade = Trades.FirstOrDefault(t => t.Id == tradeEvent.EntityId);
if (null == trade)
{
Trades.Add(new TradeViewModel(tradeEvent));
}
else
{
trade.ApplyChange(tradeEvent);
}
});
}
this.Notify(MakeEvent("TRADE", _tradeEventService.Current.Endpoint, tradeEvent.EntityId, tradeEvent.EntityId));
});
_cleanup.Add(priceServiceConnection);
//_cleanup.Add(tradeEventServiceConnection);
if (null == Application.Current.Dispatcher)
{
return;
}
await Application.Current.Dispatcher.Invoke(async() =>
{
var trades = await _tradeService.GetAllTrades();
foreach (var trade in trades)
{
var vm = new TradeViewModel(trade);
Trades.Add(vm);
}
Notify($"Fetched {trades.Count()} trade(s)");
});
}
}, () => Token == null);
Dispatcher.CurrentDispatcher.ShutdownStarted += (s, e) =>
{
_cleanup.Dispose();
};
//Logout = new Command(async() =>
//{
// try
// {
// var request = new LogoutRequest
// {
// IdTokenHint = Token.IdentityToken
// };
// await _oidcClient.LogoutAsync(request);
// Token = null;
// Notify($"Logged out");
// }
// catch (Exception ex)
// {
// Notify(ex.ToString());
// return;
// }
//});
}
public TradeRetractOffer(ITradeService tradeService)
{
_tradeService = tradeService;
}
public TradeController(ITradeService tradeService)
{
this.tradeService = tradeService;
}
public void TearDown()
{
_stockService = null;
_tradeService = null;
_claculationService = null;
}
public void Setup()
{
_stockService = new StockService();
_tradeService = new TradeService(_stockService);
_claculationService = new CalculationService(_stockService, _tradeService);
}
public NearToMarketService([NotNull] ITradeService tradeService)
{
if (tradeService == null) throw new ArgumentNullException("tradeService");
_tradeService = tradeService;
}
public EquiasManager(IEquiasAuthenticationService equiasAuthenticationService, IEquiasService equiasService, ITradeService tradeService, ITradeSummaryService tradeSummaryService,
ICashflowService cashflowService, IProfileService profileService, ISettingService settingService, IVaultService vaultService, IEquiasMappingService equiasMappingService,
ILogger <EquiasManager> logger)
{
this.equiasAuthenticationService = equiasAuthenticationService;
this.equiasService = equiasService;
this.tradeService = tradeService;
this.equiasMappingService = equiasMappingService;
this.vaultService = vaultService;
this.settingService = settingService;
this.logger = logger;
this.tradeSummaryService = tradeSummaryService;
this.cashflowService = cashflowService;
this.profileService = profileService;
}
