public TradePriceUpdateJob(ITradeService tradeService, IMarketDataService marketDataService)
{
tradeService.All
.Grouping(t => t.CurrencyPair)
.CollectionItemProcessing(
(newTradeGroup, _) =>
{
IReadScalar <MarketData> observableMarketData =
marketDataService.Get(newTradeGroup.Key);
OcConsumer consumer1 = new OcConsumer();
//DataHasChanged
newTradeGroup.CollectionItemProcessing(
(newTrade, __) =>
newTrade.MarketPrice = observableMarketData.Value.Bid)
.For(consumer1);
observableMarketData.Binding((newMarketData, __) =>
{
decimal bid = observableMarketData.Value.Bid;
newTradeGroup.ForEach(trade =>
trade.MarketPrice = bid);
}).For(consumer1);
return(consumer1);
})
.CollectionDisposing()
.For(_consumer);
}
public TradePriceUpdateJob(ITradesCache tradesCache, IMarketDataService marketDataService)
{
_job = tradesCache.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 = marketDataService.Watch(groupedData.Key)
.Synchronize(locker)
.Subscribe(price =>
{
//TODO: Bid or offer depending on Buy/Sell
latestPrice = price.Bid;
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();
}
public SuggestedStrategiesService(IOptionsPlayUow uow, IPredictionAndStdDevService predictionAndStdDevService, IMarketDataService marketDataService, IStrategyService strategyService)
: base(uow)
{
_predictionAndStdDevService = predictionAndStdDevService;
_marketDataService = marketDataService;
_strategyService = strategyService;
}
public TradePriceUpdateJob(ITradeService tradeService, IMarketDataService marketDataService)
{
_job = tradeService.All
.Connect(trade => trade.Status == TradeStatus.Live)
.Group(trade => trade.CurrencyPair)
.SubscribeMany(groupedData =>
{
object locker = new object();
decimal latestPrice = 0;
//subscribe to price and update trades with the latest price
IDisposable priceHasChanged = marketDataService.Watch(groupedData.Key)
.Synchronize(locker)
.Subscribe(price =>
{
latestPrice = price.Bid;
UpdateTradesWithPrice(groupedData.Cache.Items, latestPrice);
});
//connect to data changes and update with the latest price
IDisposable 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();
}
public GrpcApiService(
ISessionService sessionService,
ISmsVerification smsVerification,
ILogger <GrpcApiService> logger,
IAuthService authService,
IRegistrationTokenService registrationTokenService,
IEmailVerification emailVerification,
IPersonalData personalData,
IClientWalletService clientWalletService,
IClientAccountManager accountManager,
IMarketDataService marketDataService,
IMatchingEngineClient matchingEngineClient)
{
_sessionService = sessionService;
_smsVerification = smsVerification;
_logger = logger;
_authService = authService;
_registrationTokenService = registrationTokenService;
_emailVerification = emailVerification;
_personalData = personalData;
_clientWalletService = clientWalletService;
_accountManager = accountManager;
_marketDataService = marketDataService;
_matchingEngineClient = matchingEngineClient;
}
public CreateRealTimeTickingStockChartViewModel()
{
_seriesViewModels = new ObservableCollection <IRenderableSeriesViewModel>();
DateTime localDate = DateTime.Now; //Начальное время
//Загрузка данных которые хранятся в памяти
_marketDataService = new MarketDataService(localDate, 1, 1); //Время и период изменения
//Добавление модели для представления графиков
var ds0 = new XyDataSeries <DateTime, double> {
SeriesName = "Температура (*С)"
};
_seriesViewModels.Add(new LineRenderableSeriesViewModel {
DataSeries = ds0, StyleKey = "LineStyle"
});
//Добавление модели для представления графиков
var ds1 = new XyDataSeries <DateTime, double> {
SeriesName = "Давление (hPa)"
};
_seriesViewModels.Add(new LineRenderableSeriesViewModel {
DataSeries = ds1, StyleKey = "LineStyle1"
});
//Добавление модели для представления графиков
var ds2 = new XyDataSeries <DateTime, double> {
SeriesName = "Высота (м)"
};
_seriesViewModels.Add(new LineRenderableSeriesViewModel {
DataSeries = ds2, StyleKey = "LineStyle2"
});
//Добавление модели для представления графиков
var ds3 = new XyDataSeries <DateTime, double> {
SeriesName = "Влажность (%)"
};
_seriesViewModels.Add(new LineRenderableSeriesViewModel {
DataSeries = ds3, StyleKey = "LineStyle"
});
double y0 = 0;
double y1 = 0;
double y2 = 0;
double y3 = 0;
var indicators = _marketDataService.GetHistoricalData(0); //начальное значение (история)
ds0.Append(localDate, y0);
ds1.Append(localDate, y1);
ds2.Append(localDate, y2);
ds3.Append(localDate, y3);
SelectedSeriesStyle = "Line";
}
public StockTotalValueService(IStockHoldingService stockHoldingService,
IMarketDataService marketDataService,
IStockPurchaseService stockPurchaseService)
{
_stockHoldingService = stockHoldingService;
_marketDataService = marketDataService;
_stockPurchaseService = stockPurchaseService;
}
/// <summary>
/// MarketData Constructor by Id
/// </summary>
internal MarketData(IMarketDataService marketDataService, MarketDataIdentifier id)
{
EnsureArg.IsNotNull(marketDataService, nameof(marketDataService));
_marketDataService = marketDataService;
Identifier = id;
}
public StockQuoteService(IAlphaVantageAnalyzerService alphaVantageAnalyzerService,
IConnectionService connectionService,
IMarketDataService marketDataService)
{
_alphaVantageAnalyzerService = alphaVantageAnalyzerService;
_connectionService = connectionService;
_marketDataService = marketDataService;
}
public StockService(IStockData stockData,
IConnectionService connectionService,
IMarketDataService marketDataService)
{
_stockData = stockData;
_connectionService = connectionService;
_marketDataService = marketDataService;
}
/// <summary>
/// MarketAssessment Constructor
/// </summary>
internal MarketAssessment(MarketData marketData)
{
_entity = marketData._entity;
_marketDataService = marketData._marketDataService;
_identifier = new MarketDataIdentifier(_entity.ProviderName, _entity.MarketDataName);
Assessments = new List <AssessmentElement>();
}
/// <summary>
/// AuctionTimeSerie Constructor
/// </summary>
internal AuctionTimeSerie(MarketData marketData)
{
_entity = marketData._entity;
_marketDataService = marketData._marketDataService;
_identifier = new MarketDataIdentifier(_entity.ProviderName, _entity.MarketDataName);
Bids = new ReadOnlyDictionary <LocalDateTime, AuctionBids>(_bids);
}
public StockPricesViewModel(IMarketDataService marketDataService, IScheduler observeOnScheduler)
{
_marketDataService = marketDataService;
_observeOnScheduler = observeOnScheduler;
_subscriptions = new Dictionary <string, IDisposable>();
_mappedMarketData = new Dictionary <string, MarketDataViewModel>();
MarketDataCollection = new ObservableCollection <MarketDataViewModel>();
}
/// <summary>
/// BidAsks Constructor
/// </summary>
internal BidAsk(MarketData marketData)
{
_entity = marketData._entity;
_marketDataService = marketData._marketDataService;
_identifier = new MarketDataIdentifier(_entity.ProviderName, _entity.MarketDataName);
BidAsks = new List <BidAskElement>();
}
/// <summary>
/// VersionedTimeSerie Constructor
/// </summary>
internal VersionedTimeSerie(MarketData marketData)
{
_entity = marketData._entity;
_marketDataService = marketData._marketDataService;
_identifier = new MarketDataIdentifier(_entity.ProviderName, _entity.MarketDataName);
Values = new ReadOnlyDictionary <LocalDateTime, double?>(_values);
}
public StockReturnsService(IStockHoldingService stockHoldingService,
IStockService stockService,
IStockPurchaseService stockPurchaseService,
IMarketDataService marketDataService)
{
_stockHoldingService = stockHoldingService;
_stockService = stockService;
_stockPurchaseService = stockPurchaseService;
_marketDataService = marketDataService;
}
public IndexAnalysisService(IStockPurchaseService stockPurchaseService,
IStockIndexValueService stockIndexValueService,
IStockHoldingService stockHoldingService,
IMarketDataService marketDataService)
{
_stockPurchaseService = stockPurchaseService;
_stockIndexValueService = stockIndexValueService;
_stockHoldingService = stockHoldingService;
_marketDataService = marketDataService;
}
public StockIndexValueService(IStockIndexValueData stockIndexValueData,
IStockIndexTickerService stockIndexTickerService,
IConnectionService connectionService,
IMarketDataService marketDataService)
{
_stockIndexValueData = stockIndexValueData;
_stockIndexTickerService = stockIndexTickerService;
_connectionService = connectionService;
_marketDataService = marketDataService;
}
public DBInit(IMarketDataService marketDataSvc,
ITickerService tickerSvc,
IPortfolioService PortfolioSvc,
ITradeService tradeSvc)
{
this.marketDataSvc = marketDataSvc;
this.tickerSvc = tickerSvc;
this.PortfolioSvc = PortfolioSvc;
this.tradeSvc = tradeSvc;
xmlDBInit();
}
public OverviewController(
IStrategyRepository strategyRepository,
IAssetRepository assetRepository,
IMarketDataService marketDataService,
IMapper mapper)
{
_strategyRepository = strategyRepository;
_assetRepository = assetRepository;
_marketDataService = marketDataService;
_mapper = mapper;
}
public SignalsController(ISignalsProxyService signalsProxyService, IMarketDataProviderQueryable marketDataProvider,
IMarketDataService marketDataService, ISignalsCalculator signalsCalculator, ITechnicalRankService technicalRankService, SignalHelpers signalHelpers, TradeIdeasGenerator tradeIdeasGenerator)
{
_signalsProxyService = signalsProxyService;
_marketDataProvider = marketDataProvider;
_marketDataService = marketDataService;
_signalsCalculator = signalsCalculator;
_technicalRankService = technicalRankService;
_signalHelpers = signalHelpers;
_tradeIdeasGenerator = tradeIdeasGenerator;
}
public LifeTimeReturnsComparisonService(IStockPurchaseService stockPurchaseService,
IStockSaleService stockSaleService,
IConnectionService connectionService,
IMarketDataService marketDataService,
IStockIndexValueService stockIndexValueService)
{
_stockPurchaseService = stockPurchaseService;
_stockSaleService = stockSaleService;
_connectionService = connectionService;
_marketDataService = marketDataService;
_stockIndexValueService = stockIndexValueService;
}
public StockIndexComparisonService(IStockHoldingService stockHoldingService,
IStockIndexValueService stockIndexValueService,
IStockService stockService,
IStockPurchaseService stockPurchaseService,
IMarketDataService marketDataService)
{
_stockHoldingService = stockHoldingService;
_stockIndexValueService = stockIndexValueService;
_stockService = stockService;
_stockPurchaseService = stockPurchaseService;
_marketDataService = marketDataService;
}
public BinanceService(
UserManager <User> userManager,
IMarketDataService marketDataService,
IExchangeSecretRepository exchangeSecretRepository,
ITradeRepository tradeRepository)
{
_binanceWrapper = new BinanceWrapper();
_userManager = userManager;
_marketDataService = marketDataService;
_exchangeSecretRepository = exchangeSecretRepository;
_tradeRepository = tradeRepository;
}
public TradeGenerator(IStaticData staticData, IMarketDataService marketDataService)
{
_staticData = staticData;
//keep track of the latest price so we can generate trades are a reasonable distance from the market
_cleanUp = staticData.CurrencyPairs
.Select(currencypair => marketDataService.Watch(currencypair.Code)).Merge()
.Synchronize(_locker)
.Subscribe(md =>
{
_latestPrices[md.Instrument] = md;
});
}
public TradingController(
ITradeRepository tradeRepository,
ITradeExecutionService tradeExecutionService,
IMarketDataService marketDataService,
IStrategyRepository strategyRepository,
IMapper mapper)
{
_tradeRepository = tradeRepository;
_tradeService = tradeExecutionService;
_marketDataService = marketDataService;
_strategyRepository = strategyRepository;
_mapper = mapper;
}
public TradeGenerator(IStaticData staticData, IMarketDataService marketDataService)
{
_staticData = staticData;
//keep track of the latest price so we can generate trades are a reasonable distance from the market
_cleanUp = staticData.CurrencyPairs
.Select(currencypair => marketDataService.Watch(currencypair.Code)).Merge()
.Synchronize(_locker)
.Subscribe(md =>
{
_latestPrices[md.Instrument] = md;
});
}
public SZKingdomTestController(
IMarketDataProvider marketDataProvider,
IOrderManager orderManager,
IPortfolioManager portfolioManager,
IAccountManager accountManager,
IMarketDataService marketDataService)
{
_marketDataProvider = marketDataProvider;
_orderManager = orderManager;
_portfolioManager = portfolioManager;
_accountManager = accountManager;
_marketDataService = marketDataService;
}
public void SetUp()
{
var options = new DbContextOptionsBuilder <MarketContext>()
.UseInMemoryDatabase(databaseName: Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8))
.Options;
_inMemoryContext = new MarketContext(options);
_repo = new MarketDataRepository(_inMemoryContext);
var mockCache = new Moq.Mock <ICacheRepository>();
_service = new MarketDataService(_repo, mockCache.Object);
}
public MarketDataViewer(IStaticData staticData,
IMarketDataService marketDataService)
{
Prices = staticData.CurrencyPairs.Select(currencypair =>
{
var observable = marketDataService.Watch(currencypair.Code);
return(new MarketDataTicker(currencypair, observable));
}).ToList();
_cleanUp = Disposable.Create(() =>
{
Prices.OfType <IDisposable>().ForEach(d => d.Dispose());
});
}
private void InitData(IMarketDataService marketDataService)
{
var prices = marketDataService.GetHistoricalData(DefaultPointCount);
_lastPrice = prices.Last();
// Populate data series with some data
_ohlcDataSeries.Append(prices.Select(x => x.DateTime),
prices.Select(x => x.Open),
prices.Select(x => x.High),
prices.Select(x => x.Low),
prices.Select(x => x.Close));
_xyDataSeries.Append(prices.Select(x => x.DateTime), prices.Select(y => _sma50.Push(y.Close).Current));
}
public PortfolioOrchestrator(
IPortfolioManager portfolioManager,
IMarketWorkTimeService marketWorkTimeService,
IMarketDataProviderQueryable marketDataProviderQueryable,
IMarketDataService marketDataService,
IStrategyService strategyService,
IAccountManager accountManager)
{
_portfolioManager = portfolioManager;
_marketWorkTimeService = marketWorkTimeService;
_marketDataProviderQueryable = marketDataProviderQueryable;
_marketDataService = marketDataService;
_strategyService = strategyService;
_accountManager = accountManager;
}
public MarketDataViewer(IStaticData staticData,
IMarketDataService marketDataService)
{
Prices = staticData.CurrencyPairs.Select(currencypair =>
{
var observable = marketDataService.Watch(currencypair.Code);
return new MarketDataTicker(currencypair, observable);
}).ToList();
_cleanUp = Disposable.Create(() =>
{
Prices.OfType<IDisposable>().ForEach(d=>d.Dispose());
});
}
public ChartViewModel()
{
this.SetDefaults();
if (IsInDesignMode)
{
// Code runs in Blend --> create design time data.
_marketDataService = new MarketDataService(new DateTime(2015, 08, 11), 1, 5000);
}
else
{
// Code runs "for real"
_marketDataService = new MarketDataService(new DateTime(2015, 08, 11), 1, 1000);
}
var ds0 = new OhlcDataSeries<DateTime, double>();
_seriesViewModels.Add(new ChartSeriesViewModel(ds0, new FastOhlcRenderableSeries() { Name = "Series1", XAxisId = "dateTimeXAxis", YAxisId = "Y1" }));
// Append 500 historical bars to data series
var prices = _marketDataService.GetHistoricalData(500);
ds0.Append(
prices.Select(x => x.DateTime),
prices.Select(x => x.Open),
prices.Select(x => x.High),
prices.Select(x => x.Low),
prices.Select(x => x.Close));
//Create price/volume distribution
double minPrice = prices.Select(x => x.Low).Min();
double maxPrice = prices.Select(x => x.High).Max();
int numBins = 5;
double interval = (maxPrice - minPrice) / numBins;
var bins = new Tuple<double, double>[numBins];
double binLower = minPrice;
for (int i = 0; i < numBins; i++)
{
bins[i] = new Tuple<double, double>(binLower, binLower + interval);
binLower += interval;
}
var dsVolByPrice = new XyDataSeries<double, double>();
_seriesViewModels.Add(new ChartSeriesViewModel(dsVolByPrice, new FastColumnRenderableSeries() { Name = "PriceByVol", XAxisId = "verticalXAxis", YAxisId = "Y2" }));
var dblVolume = new List<double>();
for (int i = 0; i < numBins; i++) dblVolume.Add(10 - i);
dsVolByPrice.Append(bins.Select(x => x.Item1), dblVolume);
_marketDataService.SubscribePriceUpdate(OnNewPrice);
_xVisibleRange = new IndexRange(0, 1000);
SelectedChartType = ChartType.FastOhlc;
//this.DeleteCommand = new RelayCommand(DeleteCommandExecuted);
}
