/// <summary> /// Initializes a new instance of the <see cref="HighVolumeRule"/> class. /// </summary> /// <param name="equitiesParameters"> /// The equities parameters. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="orderFilter"> /// The order filter. /// </param> /// <param name="equityMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="fixedIncomeMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="tradingHoursService"> /// The trading hours service. /// </param> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <param name="currencyConverterService"> /// The currency converter service. /// </param> /// <param name="runMode"> /// The run mode. /// </param> /// <param name="logger"> /// The logger. /// </param> /// <param name="tradingHistoryLogger"> /// The trading history logger. /// </param> public HighVolumeRule( IHighVolumeRuleEquitiesParameters equitiesParameters, ISystemProcessOperationRunRuleContext operationContext, IUniverseAlertStream alertStream, IUniverseOrderFilter orderFilter, IUniverseEquityMarketCacheFactory equityMarketCacheFactory, IUniverseFixedIncomeMarketCacheFactory fixedIncomeMarketCacheFactory, IMarketTradingHoursService tradingHoursService, IUniverseDataRequestsSubscriber dataRequestSubscriber, ICurrencyConverterService currencyConverterService, RuleRunMode runMode, ILogger <IHighVolumeRule> logger, ILogger <TradingHistoryStack> tradingHistoryLogger) : base( equitiesParameters?.Windows.BackwardWindowSize ?? TimeSpan.FromDays(1), equitiesParameters?.Windows.BackwardWindowSize ?? TimeSpan.FromDays(1), equitiesParameters?.Windows?.FutureWindowSize ?? TimeSpan.Zero, Domain.Surveillance.Scheduling.Rules.HighVolume, EquityRuleHighVolumeFactory.Version, "High Volume Rule", operationContext, equityMarketCacheFactory, fixedIncomeMarketCacheFactory, runMode, logger, tradingHistoryLogger) { this.EquitiesParameters = equitiesParameters ?? throw new ArgumentNullException(nameof(equitiesParameters)); this.AlertStream = alertStream ?? throw new ArgumentNullException(nameof(alertStream)); this.OrderFilter = orderFilter ?? throw new ArgumentNullException(nameof(orderFilter)); this.TradingHoursService = tradingHoursService ?? throw new ArgumentNullException(nameof(tradingHoursService)); this.DataRequestSubscriber = dataRequestSubscriber ?? throw new ArgumentNullException(nameof(dataRequestSubscriber)); this.CurrencyConverterService = currencyConverterService ?? throw new ArgumentNullException(nameof(currencyConverterService)); this.Logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
/// <summary> /// Initializes a new instance of the <see cref="MarkingTheCloseRule"/> class. /// </summary> /// <param name="equitiesParameters"> /// The equities parameters. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="ruleContext"> /// The rule context. /// </param> /// <param name="orderFilter"> /// The order filter. /// </param> /// <param name="equityMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="fixedIncomeMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="tradingHoursService"> /// The trading hours service. /// </param> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <param name="runMode"> /// The run mode. /// </param> /// <param name="logger"> /// The logger. /// </param> /// <param name="tradingHistoryLogger"> /// The trading history logger. /// </param> public MarkingTheCloseRule( IMarkingTheCloseEquitiesParameters equitiesParameters, IUniverseAlertStream alertStream, ISystemProcessOperationRunRuleContext ruleContext, IUniverseOrderFilter orderFilter, IUniverseEquityMarketCacheFactory equityMarketCacheFactory, IUniverseFixedIncomeMarketCacheFactory fixedIncomeMarketCacheFactory, IMarketTradingHoursService tradingHoursService, IUniverseDataRequestsSubscriber dataRequestSubscriber, RuleRunMode runMode, ILogger <MarkingTheCloseRule> logger, ILogger <TradingHistoryStack> tradingHistoryLogger) : base( equitiesParameters?.Windows?.BackwardWindowSize ?? TimeSpan.FromMinutes(30), equitiesParameters?.Windows?.BackwardWindowSize ?? TimeSpan.FromMinutes(30), equitiesParameters?.Windows?.FutureWindowSize ?? TimeSpan.FromMinutes(30), Domain.Surveillance.Scheduling.Rules.MarkingTheClose, EquityRuleMarkingTheCloseFactory.Version, "Marking The Close", ruleContext, equityMarketCacheFactory, fixedIncomeMarketCacheFactory, runMode, logger, tradingHistoryLogger) { this.equitiesParameters = equitiesParameters ?? throw new ArgumentNullException(nameof(equitiesParameters)); this.alertStream = alertStream ?? throw new ArgumentNullException(nameof(alertStream)); this.ruleContext = ruleContext ?? throw new ArgumentNullException(nameof(ruleContext)); this.orderFilter = orderFilter ?? throw new ArgumentNullException(nameof(orderFilter)); this.tradingHoursService = tradingHoursService ?? throw new ArgumentNullException(nameof(tradingHoursService)); this.dataRequestSubscriber = dataRequestSubscriber ?? throw new ArgumentNullException(nameof(dataRequestSubscriber)); this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public void Setup() { this._currencyConverterService = A.Fake <ICurrencyConverterService>(); this._ruleCtx = A.Fake <ISystemProcessOperationRunRuleContext>(); this._alertStream = A.Fake <IUniverseAlertStream>(); this._clustering = new ClusteringService(); this._equitiesParameters = A.Fake <IWashTradeRuleEquitiesParameters>(); this._logger = A.Fake <ILogger>(); this._ruleRunRepository = A.Fake <IRuleRunDataRequestRepository>(); this._stubRuleRunRepository = A.Fake <IStubRuleRunDataRequestRepository>(); this._loggerEquityCache = A.Fake <ILogger <UniverseEquityMarketCacheFactory> >(); this._loggerFixedIncomeCache = A.Fake <ILogger <UniverseFixedIncomeMarketCacheFactory> >(); this._tradingLogger = A.Fake <ILogger <TradingHistoryStack> >(); this._orderFilter = A.Fake <IUniverseOrderFilter>(); this._equityFactory = new UniverseEquityMarketCacheFactory( this._stubRuleRunRepository, this._ruleRunRepository, this._loggerEquityCache); this._fixedIncomeFactory = new UniverseFixedIncomeMarketCacheFactory( this._stubRuleRunRepository, this._ruleRunRepository, this._loggerFixedIncomeCache); A.CallTo(() => this._orderFilter.Filter(A <IUniverseEvent> .Ignored)) .ReturnsLazily(i => (IUniverseEvent)i.Arguments[0]); A.CallTo(() => this._equitiesParameters.PerformClusteringPositionAnalysis).Returns(true); A.CallTo(() => this._equitiesParameters.ClusteringPercentageValueDifferenceThreshold).Returns(0.05m); }
/// <summary> /// Initializes a new instance of the <see cref="LayeringRule"/> class. /// </summary> /// <param name="equitiesParameters"> /// The equities parameters. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="orderFilter"> /// The order filter. /// </param> /// <param name="logger"> /// The logger. /// </param> /// <param name="equityMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="fixedIncomeMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="tradingHoursService"> /// The trading hours service. /// </param> /// <param name="operationContext"> /// The op context. /// </param> /// <param name="runMode"> /// The run mode. /// </param> /// <param name="tradingHistoryLogger"> /// The trading history logger. /// </param> public LayeringRule( ILayeringRuleEquitiesParameters equitiesParameters, IUniverseAlertStream alertStream, IUniverseOrderFilter orderFilter, ILogger logger, IUniverseEquityMarketCacheFactory equityMarketCacheFactory, IUniverseFixedIncomeMarketCacheFactory fixedIncomeMarketCacheFactory, IMarketTradingHoursService tradingHoursService, ISystemProcessOperationRunRuleContext operationContext, RuleRunMode runMode, ILogger <TradingHistoryStack> tradingHistoryLogger) : base( equitiesParameters?.Windows?.BackwardWindowSize ?? TimeSpan.FromMinutes(20), equitiesParameters?.Windows?.BackwardWindowSize ?? TimeSpan.FromMinutes(20), equitiesParameters?.Windows?.FutureWindowSize ?? TimeSpan.Zero, Domain.Surveillance.Scheduling.Rules.Layering, EquityRuleLayeringFactory.Version, "Layering Rule", operationContext, equityMarketCacheFactory, fixedIncomeMarketCacheFactory, runMode, logger, tradingHistoryLogger) { this.equitiesParameters = equitiesParameters ?? throw new ArgumentNullException(nameof(equitiesParameters)); this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); this.tradingHoursService = tradingHoursService ?? throw new ArgumentNullException(nameof(tradingHoursService)); this.ruleContext = operationContext ?? throw new ArgumentNullException(nameof(operationContext)); this.alertStream = alertStream ?? throw new ArgumentNullException(nameof(alertStream)); this.orderFilter = orderFilter ?? throw new ArgumentNullException(nameof(orderFilter)); }
public void Setup() { _alertStream = A.Fake <IUniverseAlertStream>(); _equitiesParameters = A.Fake <IHighVolumeRuleEquitiesParameters>(); _ruleCtx = A.Fake <ISystemProcessOperationRunRuleContext>(); _opCtx = A.Fake <ISystemProcessOperationContext>(); _dataRequestRepository = A.Fake <IRuleRunDataRequestRepository>(); _stubDataRequestRepository = A.Fake <IStubRuleRunDataRequestRepository>(); _equityFactoryCache = A.Fake <ILogger <UniverseEquityMarketCacheFactory> >(); _equityFactory = new UniverseEquityMarketCacheFactory(_stubDataRequestRepository, _dataRequestRepository, _equityFactoryCache); _fixedIncomeFactoryCache = A.Fake <ILogger <UniverseFixedIncomeMarketCacheFactory> >(); _fixedIncomeFactory = new UniverseFixedIncomeMarketCacheFactory(_stubDataRequestRepository, _dataRequestRepository, _fixedIncomeFactoryCache); _tradingHoursService = A.Fake <IMarketTradingHoursService>(); _dataRequestSubscriber = A.Fake <IUniverseDataRequestsSubscriber>(); this.currencyConverterService = A.Fake <ICurrencyConverterService>(); _logger = A.Fake <ILogger <IHighVolumeRule> >(); _tradingLogger = A.Fake <ILogger <TradingHistoryStack> >(); _orderFilter = A.Fake <IUniverseOrderFilter>(); A.CallTo(() => _orderFilter.Filter(A <IUniverseEvent> .Ignored)).ReturnsLazily(i => (IUniverseEvent)i.Arguments[0]); A.CallTo(() => _ruleCtx.EndEvent()).Returns(_opCtx); }
/// <summary> /// Initializes a new instance of the <see cref="CancelledOrderRule"/> class. /// </summary> /// <param name="parameters"> /// The parameters. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="orderFilter"> /// The order filter. /// </param> /// <param name="equityMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="fixedIncomeMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="runMode"> /// The run mode. /// </param> /// <param name="logger"> /// The logger. /// </param> /// <param name="tradingHistoryLogger"> /// The trading history logger. /// </param> public CancelledOrderRule( ICancelledOrderRuleEquitiesParameters parameters, ISystemProcessOperationRunRuleContext operationContext, IUniverseAlertStream alertStream, IUniverseOrderFilter orderFilter, IUniverseEquityMarketCacheFactory equityMarketCacheFactory, IUniverseFixedIncomeMarketCacheFactory fixedIncomeMarketCacheFactory, RuleRunMode runMode, ILogger <CancelledOrderRule> logger, ILogger <TradingHistoryStack> tradingHistoryLogger) : base( parameters?.Windows?.BackwardWindowSize ?? TimeSpan.FromMinutes(60), parameters?.Windows?.BackwardWindowSize ?? TimeSpan.FromMinutes(60), parameters?.Windows?.FutureWindowSize ?? TimeSpan.Zero, Rules.CancelledOrders, Versioner.Version(2, 0), "Cancelled Order Rule", operationContext, equityMarketCacheFactory, fixedIncomeMarketCacheFactory, runMode, logger, tradingHistoryLogger) { this.parameters = parameters ?? throw new ArgumentNullException(nameof(parameters)); this.operationContext = operationContext ?? throw new ArgumentNullException(nameof(operationContext)); this.alertStream = alertStream ?? throw new ArgumentNullException(nameof(alertStream)); this.orderFilter = orderFilter ?? throw new ArgumentNullException(nameof(orderFilter)); this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
/// <summary> /// Initializes a new instance of the <see cref="PlacingOrdersWithNoIntentToExecuteRule"/> class. /// </summary> /// <param name="parameters"> /// The parameters. /// </param> /// <param name="orderFilter"> /// The order filter. /// </param> /// <param name="ruleContext"> /// The rule context. /// </param> /// <param name="equityMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="fixedIncomeMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <param name="tradingHoursService"> /// The trading hours service. /// </param> /// <param name="runMode"> /// The run mode. /// </param> /// <param name="logger"> /// The logger. /// </param> /// <param name="tradingStackLogger"> /// The trading stack logger. /// </param> public PlacingOrdersWithNoIntentToExecuteRule( IPlacingOrderWithNoIntentToExecuteRuleEquitiesParameters parameters, IUniverseOrderFilter orderFilter, ISystemProcessOperationRunRuleContext ruleContext, IUniverseEquityMarketCacheFactory equityMarketCacheFactory, IUniverseFixedIncomeMarketCacheFactory fixedIncomeMarketCacheFactory, IUniverseAlertStream alertStream, IUniverseDataRequestsSubscriber dataRequestSubscriber, IMarketTradingHoursService tradingHoursService, RuleRunMode runMode, ILogger logger, ILogger <TradingHistoryStack> tradingStackLogger) : base( TimeSpan.FromHours(24), TimeSpan.FromHours(24), TimeSpan.Zero, Domain.Surveillance.Scheduling.Rules.PlacingOrderWithNoIntentToExecute, EquityRulePlacingOrdersWithoutIntentToExecuteFactory.Version, "Placing Orders With No Intent To Execute Rule", ruleContext, equityMarketCacheFactory, fixedIncomeMarketCacheFactory, runMode, logger, tradingStackLogger) { this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); this.ruleContext = ruleContext ?? throw new ArgumentNullException(nameof(ruleContext)); this.alertStream = alertStream ?? throw new ArgumentNullException(nameof(alertStream)); this.dataRequestSubscriber = dataRequestSubscriber ?? throw new ArgumentNullException(nameof(dataRequestSubscriber)); this.orderFilter = orderFilter ?? throw new ArgumentNullException(nameof(orderFilter)); this.parameters = parameters ?? throw new ArgumentNullException(nameof(parameters)); this.tradingHoursService = tradingHoursService ?? throw new ArgumentNullException(nameof(tradingHoursService)); }
/// <summary> /// Initializes a new instance of the <see cref="HighProfitMarketClosureRule"/> class. /// </summary> /// <param name="equitiesParameters"> /// The equities parameters. /// </param> /// <param name="ruleContext"> /// The rule context. /// </param> /// <param name="costCalculatorFactory"> /// The cost calculator factory. /// </param> /// <param name="revenueCalculatorFactory"> /// The revenue calculator factory. /// </param> /// <param name="exchangeRateProfitCalculator"> /// The exchange rate profit calculator. /// </param> /// <param name="orderFilter"> /// The order filter. /// </param> /// <param name="equityMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="fixedIncomeMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="marketDataCacheFactory"> /// The market data cache factory. /// </param> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <param name="judgementService"> /// The judgement service. /// </param> /// <param name="runMode"> /// The run mode. /// </param> /// <param name="logger"> /// The logger. /// </param> /// <param name="tradingHistoryLogger"> /// The trading history logger. /// </param> public HighProfitMarketClosureRule( IHighProfitsRuleEquitiesParameters equitiesParameters, ISystemProcessOperationRunRuleContext ruleContext, ICostCalculatorFactory costCalculatorFactory, IRevenueCalculatorFactory revenueCalculatorFactory, IExchangeRateProfitCalculator exchangeRateProfitCalculator, IUniverseOrderFilter orderFilter, IUniverseEquityMarketCacheFactory equityMarketCacheFactory, IUniverseFixedIncomeMarketCacheFactory fixedIncomeMarketCacheFactory, IEquityMarketDataCacheStrategyFactory marketDataCacheFactory, IUniverseDataRequestsSubscriber dataRequestSubscriber, IHighProfitJudgementService judgementService, ICurrencyConverterService currencyConverterService, RuleRunMode runMode, ILogger <HighProfitsRule> logger, ILogger <TradingHistoryStack> tradingHistoryLogger) : base( equitiesParameters, ruleContext, costCalculatorFactory, revenueCalculatorFactory, exchangeRateProfitCalculator, orderFilter, equityMarketCacheFactory, fixedIncomeMarketCacheFactory, marketDataCacheFactory, dataRequestSubscriber, judgementService, currencyConverterService, runMode, logger, tradingHistoryLogger) { this.MarketClosureRule = true; }
/// <summary> /// Initializes a new instance of the <see cref="SpoofingRule"/> class. /// </summary> /// <param name="equitiesParameters"> /// The equities parameters. /// </param> /// <param name="ruleContext"> /// The rule context. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="orderFilter"> /// The order filter. /// </param> /// <param name="equityMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="fixedIncomeMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="runMode"> /// The run mode. /// </param> /// <param name="portfolioFactory"> /// The portfolio factory. /// </param> /// <param name="analysisService"> /// The analysis service. /// </param> /// <param name="logger"> /// The logger. /// </param> /// <param name="tradingHistoryLogger"> /// The trading history logger. /// </param> public SpoofingRule( ISpoofingRuleEquitiesParameters equitiesParameters, ISystemProcessOperationRunRuleContext ruleContext, IUniverseAlertStream alertStream, IUniverseOrderFilter orderFilter, IUniverseEquityMarketCacheFactory equityMarketCacheFactory, IUniverseFixedIncomeMarketCacheFactory fixedIncomeMarketCacheFactory, RuleRunMode runMode, IPortfolioFactory portfolioFactory, IOrderAnalysisService analysisService, ILogger logger, ILogger <TradingHistoryStack> tradingHistoryLogger) : base( equitiesParameters?.Windows?.BackwardWindowSize ?? TimeSpan.FromMinutes(30), equitiesParameters?.Windows?.BackwardWindowSize ?? TimeSpan.FromMinutes(30), equitiesParameters?.Windows?.FutureWindowSize ?? TimeSpan.Zero, Rules.Spoofing, EquityRuleSpoofingFactory.Version, "Spoofing Rule", ruleContext, equityMarketCacheFactory, fixedIncomeMarketCacheFactory, runMode, logger, tradingHistoryLogger) { this.equitiesParameters = equitiesParameters ?? throw new ArgumentNullException(nameof(equitiesParameters)); this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); this.alertStream = alertStream ?? throw new ArgumentNullException(nameof(alertStream)); this.orderFilter = orderFilter ?? throw new ArgumentNullException(nameof(orderFilter)); this.portfolioFactory = portfolioFactory ?? throw new ArgumentNullException(nameof(portfolioFactory)); this.analysisService = analysisService ?? throw new ArgumentNullException(nameof(analysisService)); this.ruleContext = ruleContext ?? throw new ArgumentNullException(nameof(ruleContext)); }
/// <summary> /// Initializes a new instance of the <see cref="WashTradeRule"/> class. /// </summary> /// <param name="equitiesParameters"> /// The equities parameters. /// </param> /// <param name="ruleContext"> /// The rule context. /// </param> /// <param name="clustering"> /// The clustering. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="currencyConverterService"> /// The currency converter service. /// </param> /// <param name="orderFilter"> /// The order filter. /// </param> /// <param name="equityMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="fixedIncomeMarketCacheFactory"> /// The market cache factory. /// </param> /// <param name="runMode"> /// The run mode. /// </param> /// <param name="logger"> /// The logger. /// </param> /// <param name="tradingHistoryLogger"> /// The trading history logger. /// </param> public WashTradeRule( IWashTradeRuleEquitiesParameters equitiesParameters, ISystemProcessOperationRunRuleContext ruleContext, IClusteringService clustering, IUniverseAlertStream alertStream, ICurrencyConverterService currencyConverterService, IUniverseOrderFilter orderFilter, IUniverseEquityMarketCacheFactory equityMarketCacheFactory, IUniverseFixedIncomeMarketCacheFactory fixedIncomeMarketCacheFactory, RuleRunMode runMode, ILogger logger, ILogger <TradingHistoryStack> tradingHistoryLogger) : base( equitiesParameters?.Windows?.BackwardWindowSize ?? TimeSpan.FromDays(1), equitiesParameters?.Windows?.BackwardWindowSize ?? TimeSpan.FromDays(1), equitiesParameters?.Windows?.FutureWindowSize ?? TimeSpan.Zero, Rules.WashTrade, EquityRuleWashTradeFactory.Version, "Wash Trade Rule", ruleContext, equityMarketCacheFactory, fixedIncomeMarketCacheFactory, runMode, logger, tradingHistoryLogger) { this.equitiesParameters = equitiesParameters ?? throw new ArgumentNullException(nameof(equitiesParameters)); this.clustering = clustering ?? throw new ArgumentNullException(nameof(clustering)); this.currencyConverterService = currencyConverterService ?? throw new ArgumentNullException(nameof(currencyConverterService)); this.orderFilter = orderFilter ?? throw new ArgumentNullException(nameof(orderFilter)); this.alertStream = alertStream ?? throw new ArgumentNullException(nameof(alertStream)); this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
/// <summary> /// Initializes a new instance of the <see cref="FixedIncomeHighProfitsStreamRule"/> class. /// Constructor for the high profits stream rule /// </summary> /// <param name="fixedIncomeParameters"> /// parameters from the client service user interface /// </param> /// <param name="ruleContext"> /// auditing helper /// </param> /// <param name="costCalculatorFactory"> /// cost logic service factory /// </param> /// <param name="revenueCalculatorFactory"> /// revenue logic service factory /// </param> /// <param name="exchangeRateProfitCalculator"> /// exchange rate service /// </param> /// <param name="orderFilter"> /// classification financial instruments filtering service /// </param> /// <param name="equityMarketCacheFactory"> /// time bar cache factory /// </param> /// /// <param name="fixedIncomeMarketCacheFactory"> /// time bar cache factory /// </param> /// <param name="marketDataCacheFactory"> /// market time bar cache factory /// </param> /// <param name="dataRequestSubscriber"> /// data fetch pattern helper /// </param> /// <param name="judgementService"> /// rule analysis service /// </param> /// <param name="runMode"> /// forced or validation /// </param> /// <param name="logger"> /// logging helper /// </param> /// <param name="tradingHistoryLogger"> /// logging helper for trading history /// </param> public FixedIncomeHighProfitsStreamRule( IHighProfitsRuleFixedIncomeParameters fixedIncomeParameters, ISystemProcessOperationRunRuleContext ruleContext, ICostCalculatorFactory costCalculatorFactory, IRevenueCalculatorFactory revenueCalculatorFactory, IExchangeRateProfitCalculator exchangeRateProfitCalculator, IUniverseFixedIncomeOrderFilterService orderFilter, IUniverseEquityMarketCacheFactory equityMarketCacheFactory, IUniverseFixedIncomeMarketCacheFactory fixedIncomeMarketCacheFactory, IFixedIncomeMarketDataCacheStrategyFactory marketDataCacheFactory, IUniverseDataRequestsSubscriber dataRequestSubscriber, IFixedIncomeHighProfitJudgementService judgementService, ICurrencyConverterService currencyService, RuleRunMode runMode, ILogger <FixedIncomeHighProfitsRule> logger, ILogger <TradingHistoryStack> tradingHistoryLogger) : base( fixedIncomeParameters?.Windows?.BackwardWindowSize ?? TimeSpan.FromHours(8), fixedIncomeParameters?.Windows?.BackwardWindowSize ?? TimeSpan.FromHours(8), fixedIncomeParameters?.Windows?.FutureWindowSize ?? TimeSpan.Zero, Domain.Surveillance.Scheduling.Rules.FixedIncomeHighProfits, FixedIncomeHighProfitFactory.Version, "Fixed Income High Profit Rule", ruleContext, equityMarketCacheFactory, fixedIncomeMarketCacheFactory, runMode, logger, tradingHistoryLogger) { this.FixedIncomeParameters = fixedIncomeParameters ?? throw new ArgumentNullException(nameof(fixedIncomeParameters)); this.RuleCtx = ruleContext ?? throw new ArgumentNullException(nameof(ruleContext)); this.costCalculatorFactory = costCalculatorFactory ?? throw new ArgumentNullException(nameof(costCalculatorFactory)); this.revenueCalculatorFactory = revenueCalculatorFactory ?? throw new ArgumentNullException(nameof(revenueCalculatorFactory)); this.marketDataCacheFactory = marketDataCacheFactory ?? throw new ArgumentNullException(nameof(marketDataCacheFactory)); this.exchangeRateProfitCalculator = exchangeRateProfitCalculator ?? throw new ArgumentNullException( nameof(exchangeRateProfitCalculator)); this.orderFilter = orderFilter ?? throw new ArgumentNullException(nameof(orderFilter)); this.dataRequestSubscriber = dataRequestSubscriber ?? throw new ArgumentNullException(nameof(dataRequestSubscriber)); this.JudgementService = judgementService ?? throw new ArgumentNullException(nameof(judgementService)); this.currencyConverterService = currencyService ?? throw new ArgumentNullException(nameof(currencyService)); this.Logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public void Setup() { this._equityMarketCacheFactory = A.Fake <IUniverseEquityMarketCacheFactory>(); this._fixedIncomeMarketCacheFactory = A.Fake <IUniverseFixedIncomeMarketCacheFactory>(); this._ruleRunContext = A.Fake <ISystemProcessOperationRunRuleContext>(); this._ruleRunMode = RuleRunMode.ValidationRun; this._universeOrderFilter = A.Fake <IUniverseOrderFilter>(); this._timeWindows = new TimeWindows("id-1", TimeSpan.FromDays(1)); this._decimalRangeRuleFilter = new DecimalRangeRuleFilter(); this._marketTradingHoursService = A.Fake <IMarketTradingHoursService>(); this._dataRequestSubscriber = A.Fake <IUniverseDataRequestsSubscriber>(); this._baseLogger = A.Fake <ILogger>(); this._tradingLogger = A.Fake <ILogger <TradingHistoryStack> >(); this._logger = A.Fake <ILogger <HighVolumeVenueFilter> >(); A.CallTo(() => this._universeOrderFilter.Filter(A <IUniverseEvent> .Ignored)) .ReturnsLazily(_ => _.Arguments.First() as IUniverseEvent); var repository = A.Fake <IMarketOpenCloseApiCachingDecorator>(); A.CallTo(() => repository.GetAsync()).Returns( new[] { new ExchangeDto { Code = "XLON", MarketOpenTime = TimeSpan.FromHours(8), MarketCloseTime = TimeSpan.FromHours(16), IsOpenOnMonday = true, IsOpenOnTuesday = true, IsOpenOnWednesday = true, IsOpenOnThursday = true, IsOpenOnFriday = true, IsOpenOnSaturday = true, IsOpenOnSunday = true }, new ExchangeDto { Code = "NASDAQ", MarketOpenTime = TimeSpan.FromHours(15), MarketCloseTime = TimeSpan.FromHours(23), IsOpenOnMonday = true, IsOpenOnTuesday = true, IsOpenOnWednesday = true, IsOpenOnThursday = true, IsOpenOnFriday = true, IsOpenOnSaturday = true, IsOpenOnSunday = true } }); this._tradingHoursService = new MarketTradingHoursService( repository, new NullLogger <MarketTradingHoursService>()); }
public void Setup() { this._ruleCtx = A.Fake <ISystemProcessOperationRunRuleContext>(); this._parameters = A.Fake <ICancelledOrderRuleEquitiesParameters>(); this._alertStream = A.Fake <IUniverseAlertStream>(); this._equityCacheFactory = A.Fake <IUniverseEquityMarketCacheFactory>(); this._fixedIncomeCacheFactory = A.Fake <IUniverseFixedIncomeMarketCacheFactory>(); this._ruleRunRepository = A.Fake <IRuleRunDataRequestRepository>(); this._stubRuleRunRepository = A.Fake <IStubRuleRunDataRequestRepository>(); this._equityLoggerCache = A.Fake <ILogger <UniverseEquityMarketCacheFactory> >(); this._fixedIncomeLoggerCache = A.Fake <ILogger <UniverseFixedIncomeMarketCacheFactory> >(); this._logger = A.Fake <ILogger <CancelledOrderRule> >(); this._tradingHistoryLogger = A.Fake <ILogger <TradingHistoryStack> >(); this._orderFilter = A.Fake <IUniverseOrderFilter>(); A.CallTo(() => this._orderFilter.Filter(A <IUniverseEvent> .Ignored)) .ReturnsLazily(i => (IUniverseEvent)i.Arguments[0]); }
public void Setup() { _logger = A.Fake <ILogger>(); _tradingLogger = A.Fake <ILogger <TradingHistoryStack> >(); _alertStream = A.Fake <IUniverseAlertStream>(); _ruleCtx = A.Fake <ISystemProcessOperationRunRuleContext>(); _operationCtx = A.Fake <ISystemProcessOperationContext>(); _equitiesParameters = new LayeringRuleEquitiesParameters("id", TimeSpan.FromMinutes(30), 0.2m, null, null, null, false, true); _orderFilter = A.Fake <IUniverseOrderFilter>(); A.CallTo(() => _orderFilter.Filter(A <IUniverseEvent> .Ignored)).ReturnsLazily(i => (IUniverseEvent)i.Arguments[0]); _ruleRunRepository = A.Fake <IRuleRunDataRequestRepository>(); _stubRuleRunRepository = A.Fake <IStubRuleRunDataRequestRepository>(); _equityFactoryLogger = A.Fake <ILogger <UniverseEquityMarketCacheFactory> >(); _equityFactory = new UniverseEquityMarketCacheFactory(_stubRuleRunRepository, _ruleRunRepository, _equityFactoryLogger); _fixedIncomeFactoryLogger = A.Fake <ILogger <UniverseFixedIncomeMarketCacheFactory> >(); _fixedIncomeFactory = new UniverseFixedIncomeMarketCacheFactory(_stubRuleRunRepository, _ruleRunRepository, _fixedIncomeFactoryLogger); _tradingHoursService = A.Fake <IMarketTradingHoursService>(); _tradingHoursRepository = A.Fake <IMarketOpenCloseApiCachingDecorator>(); A.CallTo(() => _tradingHoursRepository.GetAsync()) .Returns( new ExchangeDto[] { new ExchangeDto { Code = "XLON", MarketOpenTime = TimeSpan.FromHours(8), MarketCloseTime = TimeSpan.FromHours(16), IsOpenOnMonday = true, IsOpenOnTuesday = true, IsOpenOnWednesday = true, IsOpenOnThursday = true, IsOpenOnFriday = true, IsOpenOnSaturday = true, IsOpenOnSunday = true, } }); A.CallTo(() => _ruleCtx.EndEvent()).Returns(_operationCtx); }
/// <summary> /// Initializes a new instance of the <see cref="HighVolumeVenueFilter"/> class. /// </summary> /// <param name="timeWindows"> /// The time windows. /// </param> /// <param name="decimalRangeRuleFilter"> /// The decimal range rule filter. /// </param> /// <param name="universeOrderFilter"> /// The universe order filter. /// </param> /// <param name="runRuleContext"> /// The run rule context. /// </param> /// <param name="equityMarketCacheFactory"> /// The universe market cache factory. /// </param> /// <param name="fixedIncomeMarketCacheFactory"> /// The universe market cache factory. /// </param> /// <param name="ruleRunMode"> /// The rule run mode. /// </param> /// <param name="marketTradingHoursService"> /// The market trading hours service. /// </param> /// <param name="dataRequestsSubscriber"> /// The data requests subscriber. /// </param> /// <param name="source"> /// The source. /// </param> /// <param name="stackLogger"> /// The stack logger. /// </param> /// <param name="logger"> /// The logger. /// </param> public HighVolumeVenueFilter( TimeWindows timeWindows, DecimalRangeRuleFilter decimalRangeRuleFilter, IUniverseOrderFilter universeOrderFilter, ISystemProcessOperationRunRuleContext runRuleContext, IUniverseEquityMarketCacheFactory equityMarketCacheFactory, IUniverseFixedIncomeMarketCacheFactory fixedIncomeMarketCacheFactory, RuleRunMode ruleRunMode, IMarketTradingHoursService marketTradingHoursService, IUniverseDataRequestsSubscriber dataRequestsSubscriber, DataSource source, ILogger <TradingHistoryStack> stackLogger, ILogger <HighVolumeVenueFilter> logger) : base( timeWindows.BackwardWindowSize, timeWindows.BackwardWindowSize, timeWindows.FutureWindowSize, Domain.Surveillance.Scheduling.Rules.UniverseFilter, Versioner.Version(1, 0), nameof(HighVolumeVenueFilter), runRuleContext, equityMarketCacheFactory, fixedIncomeMarketCacheFactory, ruleRunMode, logger, stackLogger) { this.eventExpiration = this.TradeBackwardWindowSize + this.TradeBackwardWindowSize + TimeSpan.FromDays(3); this.tradingHoursService = marketTradingHoursService ?? throw new ArgumentNullException(nameof(marketTradingHoursService)); this.decimalRangeRuleFilter = decimalRangeRuleFilter ?? DecimalRangeRuleFilter.None(); this.orderFilter = universeOrderFilter ?? throw new ArgumentNullException(nameof(universeOrderFilter)); this.dataRequestSubscriber = dataRequestsSubscriber ?? throw new ArgumentNullException(nameof(dataRequestsSubscriber)); this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); this.UniverseEventsPassedFilter = new HashSet <Order>(); this.source = source; }
/// <summary> /// Initializes a new instance of the <see cref="RampingRule"/> class. /// </summary> /// <param name="rampingParameters"> /// The ramping parameters. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="ruleContext"> /// The rule context. /// </param> /// <param name="equityFactory"> /// The factory. /// </param> /// <param name="fixedIncomeFactory"> /// The factory. /// </param> /// <param name="orderFilter"> /// The order filter. /// </param> /// <param name="runMode"> /// The run mode. /// </param> /// <param name="rampingAnalyzer"> /// The ramping analyzer. /// </param> /// <param name="tradingHoursService"> /// The trading hours service. /// </param> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <param name="logger"> /// The logger. /// </param> /// <param name="tradingStackLogger"> /// The trading stack logger. /// </param> public RampingRule( IRampingRuleEquitiesParameters rampingParameters, IUniverseAlertStream alertStream, ISystemProcessOperationRunRuleContext ruleContext, IUniverseEquityMarketCacheFactory equityFactory, IUniverseFixedIncomeMarketCacheFactory fixedIncomeFactory, IUniverseOrderFilter orderFilter, RuleRunMode runMode, IRampingAnalyser rampingAnalyzer, IMarketTradingHoursService tradingHoursService, IUniverseDataRequestsSubscriber dataRequestSubscriber, ILogger logger, ILogger <TradingHistoryStack> tradingStackLogger) : base( rampingParameters?.Windows?.BackwardWindowSize ?? TimeSpan.FromDays(7), TimeSpan.FromDays(30), rampingParameters?.Windows?.FutureWindowSize ?? TimeSpan.Zero, Domain.Surveillance.Scheduling.Rules.Ramping, EquityRuleRampingFactory.Version, "Ramping Rule", ruleContext, equityFactory, fixedIncomeFactory, runMode, logger, tradingStackLogger) { this.rampingParameters = rampingParameters ?? throw new ArgumentNullException(nameof(rampingParameters)); this.alertStream = alertStream ?? throw new ArgumentNullException(nameof(alertStream)); this.ruleContext = ruleContext ?? throw new ArgumentNullException(nameof(ruleContext)); this.orderFilter = orderFilter ?? throw new ArgumentNullException(nameof(orderFilter)); this.rampingAnalyzer = rampingAnalyzer ?? throw new ArgumentNullException(nameof(rampingAnalyzer)); this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); this.tradingHoursService = tradingHoursService ?? throw new ArgumentNullException(nameof(tradingHoursService)); this.dataRequestSubscriber = dataRequestSubscriber ?? throw new ArgumentNullException(nameof(dataRequestSubscriber)); }