/// <summary> /// The subscribe to universe. /// </summary> /// <param name="execution"> /// The execution. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <param name="highProfitParameters"> /// The high profit parameters. /// </param> /// <param name="judgementService"> /// The judgement service. /// </param> /// <returns> /// The <see cref="IUniverseRule"/>. /// </returns> private IReadOnlyCollection <IUniverseRule> SubscribeToUniverse( ScheduledExecution execution, ISystemProcessOperationContext operationContext, IUniverseDataRequestsSubscriber dataRequestSubscriber, IReadOnlyCollection <IHighProfitsRuleFixedIncomeParameters> highProfitParameters, IJudgementService judgementService) { var subscriptions = new List <IUniverseRule>(); // ReSharper disable once ConditionIsAlwaysTrueOrFalse if (highProfitParameters != null && highProfitParameters.Any()) { foreach (var param in highProfitParameters) { var paramSubscriptions = this.SubscribeToParameters( execution, operationContext, dataRequestSubscriber, param, judgementService); subscriptions.Add(paramSubscriptions); } } else { var errorMessage = $"tried to schedule a {nameof(FixedIncomeHighProfitsRule)} rule execution with no parameters set"; this.logger.LogError(errorMessage); operationContext.EventError(errorMessage); } return(subscriptions); }
/// <summary> /// The subscribe to universe. /// </summary> /// <param name="execution"> /// The execution. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <param name="judgementService"> /// The judgement service. /// </param> /// <param name="highProfitParameters"> /// The high profit parameters. /// </param> /// <returns> /// The <see cref="IUniverseRule"/>. /// </returns> private IReadOnlyCollection <IUniverseRule> SubscribeToUniverse( ScheduledExecution execution, ISystemProcessOperationContext operationContext, IUniverseDataRequestsSubscriber dataRequestSubscriber, IJudgementService judgementService, IReadOnlyCollection <IHighProfitsRuleEquitiesParameters> highProfitParameters) { var subscriptions = new List <IUniverseRule>(); if (highProfitParameters != null && highProfitParameters.Any()) { foreach (var param in highProfitParameters) { var cloneableRule = this.SubscribeParameters( execution, operationContext, dataRequestSubscriber, judgementService, param); subscriptions.Add(cloneableRule); } } else { const string ErrorMessage = "tried to schedule a high profit rule execution with no parameters set"; this.logger.LogError(ErrorMessage); operationContext.EventError(ErrorMessage); } return(subscriptions); }
/// <summary> /// The subscribe to parameters. /// </summary> /// <param name="execution"> /// The execution. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="universeDataRequestsSubscriber"> /// The universe data requests subscriber. /// </param> /// <param name="parameter"> /// The parameter. /// </param> /// <returns> /// The <see cref="IUniverseRule"/>. /// </returns> private IUniverseRule SubscribeToParameters( ScheduledExecution execution, ISystemProcessOperationContext operationContext, IUniverseAlertStream alertStream, IUniverseDataRequestsSubscriber universeDataRequestsSubscriber, IWashTradeRuleFixedIncomeParameters parameter) { var ctx = operationContext.CreateAndStartRuleRunContext( Rules.FixedIncomeWashTrades.GetDescription(), FixedIncomeWashTradeFactory.Version, parameter.Id, (int)Rules.FixedIncomeWashTrades, execution.IsBackTest, execution.TimeSeriesInitiation.DateTime, execution.TimeSeriesTermination.DateTime, execution.CorrelationId, execution.IsForceRerun); var runMode = execution.IsForceRerun ? RuleRunMode.ForceRun : RuleRunMode.ValidationRun; var washTrade = this.fixedIncomeRuleWashTradeFactory.BuildRule(parameter, ctx, alertStream, runMode); var washTradeOrgFactors = this.brokerServiceFactory.Build( washTrade, parameter.Factors, parameter.AggregateNonFactorableIntoOwnCategory); var washTradeFilters = this.DecorateWithFilters( operationContext, parameter, washTradeOrgFactors, universeDataRequestsSubscriber, ctx, runMode); return(washTradeFilters); }
/// <summary> /// The subscribe for parameters. /// </summary> /// <param name="execution"> /// The execution. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="universeDataRequestsSubscriber"> /// The universe data requests subscriber. /// </param> /// <param name="parameter"> /// The parameter. /// </param> /// <returns> /// The <see cref="IUniverseRule"/>. /// </returns> private IUniverseRule SubscribeForParameters( ScheduledExecution execution, ISystemProcessOperationContext operationContext, IUniverseAlertStream alertStream, IUniverseDataRequestsSubscriber universeDataRequestsSubscriber, ISpoofingRuleEquitiesParameters parameter) { var ruleCtx = operationContext.CreateAndStartRuleRunContext( Rules.Spoofing.GetDescription(), EquityRuleSpoofingFactory.Version, parameter.Id, (int)Rules.Spoofing, execution.IsBackTest, execution.TimeSeriesInitiation.DateTime, execution.TimeSeriesTermination.DateTime, execution.CorrelationId, execution.IsForceRerun); var runMode = execution.IsForceRerun ? RuleRunMode.ForceRun : RuleRunMode.ValidationRun; var spoofingRule = this.equityRuleSpoofingFactory.Build(parameter, ruleCtx, alertStream, runMode); var spoofingRuleOrgFactors = this.brokerServiceFactory.Build( spoofingRule, parameter.Factors, parameter.AggregateNonFactorableIntoOwnCategory); var filteredSpoofingRule = this.DecorateWithFilters( operationContext, parameter, spoofingRuleOrgFactors, universeDataRequestsSubscriber, ruleCtx, runMode); return(filteredSpoofingRule); }
/// <summary> /// Initializes a new instance of the <see cref="FixedIncomeHighVolumeRule"/> class. /// </summary> /// <param name="parameters"> /// The parameters. /// </param> /// <param name="orderFilterService"> /// The order filter service. /// </param> /// <param name="ruleContext"> /// The rule context. /// </param> /// <param name="equityFactory"> /// The factory. /// </param> /// <param name="fixedIncomeFactory"> /// The factory. /// </param> /// <param name="judgementService"> /// The judgement service. /// </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 FixedIncomeHighVolumeRule( IHighVolumeIssuanceRuleFixedIncomeParameters parameters, IUniverseFixedIncomeOrderFilterService orderFilterService, ISystemProcessOperationRunRuleContext ruleContext, IUniverseEquityMarketCacheFactory equityFactory, IUniverseFixedIncomeMarketCacheFactory fixedIncomeFactory, IFixedIncomeHighVolumeJudgementService judgementService, IUniverseDataRequestsSubscriber dataRequestSubscriber, IMarketTradingHoursService tradingHoursService, RuleRunMode runMode, ILogger <FixedIncomeHighVolumeRule> logger, ILogger <TradingHistoryStack> tradingStackLogger) : base( parameters.Windows.BackwardWindowSize, parameters.Windows.BackwardWindowSize, parameters.Windows.FutureWindowSize, Rules.FixedIncomeHighVolumeIssuance, FixedIncomeHighVolumeFactory.Version, $"{nameof(FixedIncomeHighVolumeRule)}", ruleContext, equityFactory, fixedIncomeFactory, runMode, logger, tradingStackLogger) { this.parameters = parameters ?? throw new ArgumentNullException(nameof(parameters)); this.orderFilterService = orderFilterService ?? throw new ArgumentNullException(nameof(orderFilterService)); this.judgementService = judgementService ?? throw new ArgumentNullException(nameof(judgementService)); this.dataRequestSubscriber = dataRequestSubscriber ?? throw new ArgumentNullException(nameof(dataRequestSubscriber)); this.tradingHoursService = tradingHoursService ?? throw new ArgumentNullException(nameof(tradingHoursService)); this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
/// <summary> /// The build subscriptions. /// </summary> /// <param name="execution"> /// The execution. /// </param> /// <param name="player"> /// The player. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <param name="judgementService"> /// The judgement service. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="ruleParameters"> /// The rule parameters. /// </param> /// <param name="args"> /// The args. /// </param> /// <returns> /// The <see cref="IUniverseRule"/>. /// </returns> private IReadOnlyCollection <IUniverseRule> BuildSubscriptions( ScheduledExecution execution, IUniversePlayer player, IUniverseAlertStream alertStream, IUniverseDataRequestsSubscriber dataRequestSubscriber, IJudgementService judgementService, ISystemProcessOperationContext operationContext, RuleParameterDto ruleParameters, params Func <ScheduledExecution, RuleParameterDto, ISystemProcessOperationContext, IUniverseDataRequestsSubscriber, IJudgementService, IUniverseAlertStream, IReadOnlyCollection <IUniverseRule> >[] args) { var universeRules = new List <IUniverseRule>(); foreach (var func in args) { var result = func.Invoke( execution, ruleParameters, operationContext, dataRequestSubscriber, judgementService, alertStream); universeRules.AddRange(result); } return(universeRules); }
/// <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)); }
/// <summary> /// The collate subscriptions. /// </summary> /// <param name="execution"> /// The execution. /// </param> /// <param name="ruleParameters"> /// The rule parameters. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <param name="judgementService"> /// The judgement service. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <returns> /// The <see cref="IUniverseRule"/>. /// </returns> public IReadOnlyCollection <IUniverseRule> CollateSubscriptions( ScheduledExecution execution, RuleParameterDto ruleParameters, ISystemProcessOperationContext operationContext, IUniverseDataRequestsSubscriber dataRequestSubscriber, IJudgementService judgementService, IUniverseAlertStream alertStream) { if (!execution.Rules?.Select(_ => _.Rule)?.Contains(Rules.PlacingOrderWithNoIntentToExecute) ?? true) { return(new IUniverseRule[0]); } var filteredParameters = execution.Rules.SelectMany(_ => _.Ids).Where(_ => _ != null).ToList(); var dtos = ruleParameters.PlacingOrders .Where(_ => filteredParameters.Contains(_.Id, StringComparer.InvariantCultureIgnoreCase)).ToList(); var placingOrderParameters = this.ruleParameterMapper.Map(execution, dtos); var subscriptions = this.SubscribeToUniverse( execution, operationContext, alertStream, placingOrderParameters, dataRequestSubscriber); return(subscriptions); }
/// <summary> /// The collate subscriptions. /// </summary> /// <param name="execution"> /// The execution. /// </param> /// <param name="ruleParameters"> /// The rule parameters. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <param name="judgementService"> /// The judgement service. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <returns> /// The <see cref="IUniverseEvent"/>. /// </returns> public IReadOnlyCollection <IUniverseRule> CollateSubscriptions( ScheduledExecution execution, RuleParameterDto ruleParameters, ISystemProcessOperationContext operationContext, IUniverseDataRequestsSubscriber dataRequestSubscriber, IJudgementService judgementService, IUniverseAlertStream alertStream) { if (!execution.Rules?.Select(ru => ru.Rule).Contains(Rules.FixedIncomeWashTrades) ?? true) { return(new IUniverseRule[0]); } var filteredParameters = execution.Rules.SelectMany(ru => ru.Ids).Where(ru => ru != null).ToList(); var dtos = ruleParameters.FixedIncomeWashTrades.Where( wt => filteredParameters.Contains(wt.Id, StringComparer.InvariantCultureIgnoreCase)).ToList(); var fixedIncomeWashTradeParameters = this.ruleParameterMapper.Map(execution, dtos); var subscriptions = this.SubscribeToUniverse( execution, operationContext, alertStream, dataRequestSubscriber, fixedIncomeWashTradeParameters); return(subscriptions); }
/// <summary> /// The subscribe to universe. /// </summary> /// <param name="execution"> /// The execution. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="rampingParameters"> /// The ramping parameters. /// </param> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <returns> /// The <see cref="IUniverseRule"/>. /// </returns> private IReadOnlyCollection <IUniverseRule> SubscribeToUniverse( ScheduledExecution execution, ISystemProcessOperationContext operationContext, IUniverseAlertStream alertStream, IReadOnlyCollection <IRampingRuleEquitiesParameters> rampingParameters, IUniverseDataRequestsSubscriber dataRequestSubscriber) { var subscriptions = new List <IUniverseRule>(); if (rampingParameters != null && rampingParameters.Any()) { foreach (var param in rampingParameters) { var baseSubscriber = this.SubscribeParameterToUniverse( execution, operationContext, alertStream, param, dataRequestSubscriber); subscriptions.Add(baseSubscriber); } } else { const string ErrorMessage = "tried to schedule a cancelled order rule execution with no parameters set"; this.logger.LogError(ErrorMessage); operationContext.EventError(ErrorMessage); } return(subscriptions); }
/// <summary> /// The subscribe to universe. /// </summary> /// <param name="execution"> /// The execution. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="universeDataRequestsSubscriber"> /// The universe data requests subscriber. /// </param> /// <param name="washTradeParameters"> /// The wash trade parameters. /// </param> /// <returns> /// The <see cref="IUniverseRule"/>. /// </returns> private IReadOnlyCollection <IUniverseRule> SubscribeToUniverse( ScheduledExecution execution, ISystemProcessOperationContext operationContext, IUniverseAlertStream alertStream, IUniverseDataRequestsSubscriber universeDataRequestsSubscriber, IReadOnlyCollection <IWashTradeRuleFixedIncomeParameters> washTradeParameters) { var subscriptions = new List <IUniverseRule>(); if (washTradeParameters != null && washTradeParameters.Any()) { foreach (var param in washTradeParameters) { var paramSubscriptions = this.SubscribeToParameters( execution, operationContext, alertStream, universeDataRequestsSubscriber, param); subscriptions.Add(paramSubscriptions); } } else { const string ErrorMessage = "tried to schedule a wash trade rule execution with no parameters set"; this.logger.LogError(ErrorMessage); operationContext.EventError(ErrorMessage); } return(subscriptions); }
/// <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; }
public HighMarketCapFilter( IUniverseEquityMarketCacheFactory factory, RuleRunMode ruleRunMode, DecimalRangeRuleFilter marketCap, IMarketTradingHoursService tradingHoursService, ISystemProcessOperationRunRuleContext operationRunRuleContext, IUniverseDataRequestsSubscriber universeDataRequestsSubscriber, ICurrencyConverterService currencyConverterService, string ruleName, ILogger <HighMarketCapFilter> logger ) { _universeEquityInterdayCache = factory?.BuildInterday(ruleRunMode) ?? throw new ArgumentNullException(nameof(factory)); _ruleRunMode = ruleRunMode; _marketCapFilter = marketCap ?? DecimalRangeRuleFilter.None(); _tradingHoursService = tradingHoursService ?? throw new ArgumentNullException(nameof(tradingHoursService)); _operationRunRuleContext = operationRunRuleContext ?? throw new ArgumentNullException(nameof(operationRunRuleContext)); _universeDataRequestsSubscriber = universeDataRequestsSubscriber; this.currencyConverterService = currencyConverterService ?? throw new ArgumentNullException(nameof(currencyConverterService)); _name = ruleName; _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
/// <summary> /// The decorate with filters. /// </summary> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="parameters"> /// The parameters. /// </param> /// <param name="washTrade"> /// The wash trade. /// </param> /// <param name="universeDataRequestsSubscriber"> /// The universe data requests subscriber. /// </param> /// <param name="processOperationRunRuleContext"> /// The process operation run rule context. /// </param> /// <param name="ruleRunMode"> /// The rule run mode. /// </param> /// <returns> /// The <see cref="IUniverseRule"/>. /// </returns> private IUniverseRule DecorateWithFilters( ISystemProcessOperationContext operationContext, IWashTradeRuleFixedIncomeParameters parameters, IUniverseRule washTrade, IUniverseDataRequestsSubscriber universeDataRequestsSubscriber, ISystemProcessOperationRunRuleContext processOperationRunRuleContext, RuleRunMode ruleRunMode) { if (parameters.HasInternalFilters()) { this.logger.LogInformation($"parameters had filters. Inserting filtered universe in {operationContext.Id} OpCtx"); var filteredUniverse = this.universeFilterFactory.Build( washTrade, parameters.Accounts, parameters.Traders, parameters.Markets, parameters.Funds, parameters.Strategies, null, null, null, null, null, ruleRunMode, "Wash Trade Fixed Income", universeDataRequestsSubscriber, processOperationRunRuleContext); filteredUniverse.Subscribe(washTrade); return(filteredUniverse); } return(washTrade); }
public IHighVolumeVenueDecoratorFilter Build( TimeWindows timeWindows, IUniverseFilterService baseService, DecimalRangeRuleFilter venueVolumeFilterSetting, ISystemProcessOperationRunRuleContext ruleRunContext, IUniverseDataRequestsSubscriber dataRequestSubscriber, DataSource dataSource, RuleRunMode ruleRunMode) { var filterRule = new HighVolumeVenueFilter( timeWindows, venueVolumeFilterSetting, this._equityOrderFilterService, ruleRunContext, this._equityMarketCacheFactory, this._fixedIncomeMarketCacheFactory, ruleRunMode, this._marketTradingHoursService, dataRequestSubscriber, dataSource, this._tradingHistoryLogger, this._venueLogger); var filter = new HighVolumeVenueDecoratorFilter(timeWindows, baseService, filterRule); return(filter); }
/// <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="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> /// The subscribe to universe. /// </summary> /// <param name="execution"> /// The execution. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="alertStream"> /// The alert stream. /// </param> /// <param name="universeDataRequestsSubscriber"> /// The universe data requests subscriber. /// </param> /// <param name="layeringParameters"> /// The layering parameters. /// </param> /// <returns> /// The <see cref="IUniverseRule"/>. /// </returns> private IReadOnlyCollection <IUniverseRule> SubscribeToUniverse( ScheduledExecution execution, ISystemProcessOperationContext operationContext, IUniverseAlertStream alertStream, IUniverseDataRequestsSubscriber universeDataRequestsSubscriber, IReadOnlyCollection <ILayeringRuleEquitiesParameters> layeringParameters) { var subscriptions = new List <IUniverseRule>(); // ReSharper disable once ConditionIsAlwaysTrueOrFalse if (layeringParameters != null && layeringParameters.Any()) { foreach (var param in layeringParameters) { var paramSubscriptions = this.SubscribeToParameters( execution, operationContext, alertStream, universeDataRequestsSubscriber, param); subscriptions.Add(paramSubscriptions); } } else { const string ErrorMessage = "tried to schedule a layering rule execution with no parameters set"; this.logger.LogError(ErrorMessage); operationContext.EventError(ErrorMessage); } return(subscriptions); }
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="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>()); }
/// <summary> /// The subscribe parameters. /// </summary> /// <param name="execution"> /// The execution. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <param name="judgementService"> /// The judgement service. /// </param> /// <param name="parameter"> /// The parameter. /// </param> /// <returns> /// The <see cref="IUniverseRule"/>. /// </returns> private IUniverseRule SubscribeParameters( ScheduledExecution execution, ISystemProcessOperationContext operationContext, IUniverseDataRequestsSubscriber dataRequestSubscriber, IJudgementService judgementService, IHighProfitsRuleEquitiesParameters parameter) { var ruleCtxStream = operationContext.CreateAndStartRuleRunContext( Rules.HighProfits.GetDescription(), EquityRuleHighProfitFactory.Version, parameter.Id, (int)Rules.HighProfits, execution.IsBackTest, execution.TimeSeriesInitiation.DateTime, execution.TimeSeriesTermination.DateTime, execution.CorrelationId, execution.IsForceRerun); var ruleCtxMarketClosure = operationContext.CreateAndStartRuleRunContext( Rules.HighProfits.GetDescription(), EquityRuleHighProfitFactory.Version, parameter.Id, (int)Rules.HighProfits, execution.IsBackTest, execution.TimeSeriesInitiation.DateTime, execution.TimeSeriesTermination.DateTime, execution.CorrelationId, execution.IsForceRerun); var highProfitsRule = this.equityRuleHighProfitFactory.Build( parameter, ruleCtxStream, ruleCtxMarketClosure, dataRequestSubscriber, judgementService, execution); var highProfitsRuleOrgFactor = this.brokerServiceFactory.Build( highProfitsRule, parameter.Factors, parameter.AggregateNonFactorableIntoOwnCategory); var runMode = execution.IsForceRerun ? RuleRunMode.ForceRun : RuleRunMode.ValidationRun; var decoratedHighProfits = this.DecorateWithFilter( operationContext, parameter, highProfitsRuleOrgFactor, dataRequestSubscriber, ruleCtxMarketClosure, runMode); return(decoratedHighProfits); }
/// <summary> /// The decorate with filter. /// </summary> /// <param name="operationContext"> /// The operation context. /// </param> /// <param name="parameter"> /// The parameter. /// </param> /// <param name="layering"> /// The layering. /// </param> /// <param name="universeDataRequestsSubscriber"> /// The universe data requests subscriber. /// </param> /// <param name="processOperationRunRuleContext"> /// The process operation run rule context. /// </param> /// <param name="ruleRunMode"> /// The rule run mode. /// </param> /// <returns> /// The <see cref="IUniverseRule"/>. /// </returns> private IUniverseRule DecorateWithFilter( ISystemProcessOperationContext operationContext, ILayeringRuleEquitiesParameters parameter, IUniverseRule layering, IUniverseDataRequestsSubscriber universeDataRequestsSubscriber, ISystemProcessOperationRunRuleContext processOperationRunRuleContext, RuleRunMode ruleRunMode) { if (parameter.HasInternalFilters() || parameter.HasReferenceDataFilters() || parameter.HasMarketCapFilters() || parameter.HasVenueVolumeFilters()) { this.logger.LogInformation($"parameters had filters. Inserting filtered universe in {operationContext.Id} OpCtx"); var filteredUniverse = this.universeFilterFactory.Build( layering, parameter.Accounts, parameter.Traders, parameter.Markets, parameter.Funds, parameter.Strategies, parameter.Sectors, parameter.Industries, parameter.Regions, parameter.Countries, parameter.MarketCapFilter, ruleRunMode, "Layering Equity", universeDataRequestsSubscriber, processOperationRunRuleContext); var decoratedFilters = filteredUniverse; if (parameter.HasVenueVolumeFilters()) { decoratedFilters = this.decoratorFilterFactory.Build( parameter.Windows, filteredUniverse, parameter.VenueVolumeFilter, processOperationRunRuleContext, universeDataRequestsSubscriber, this.LayeringDataSource(parameter), ruleRunMode); } decoratedFilters.Subscribe(layering); return(decoratedFilters); } return(layering); }
/// <summary> /// The set operation context end state. /// </summary> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <param name="operationContext"> /// The operation context. /// </param> private void SetOperationContextEndState( IUniverseDataRequestsSubscriber dataRequestSubscriber, ISystemProcessOperationContext operationContext) { if (!dataRequestSubscriber?.SubmitRequests ?? true) { this.logger.LogInformation("ending operation context event"); operationContext.EndEvent(); return; } this.logger.LogInformation("ending operating context event with missing data error"); operationContext.EndEventWithMissingDataError(); }
public void Setup() { this._orderFilterService = A.Fake <IUniverseEquityOrderFilterService>(); this._equityFactory = A.Fake <IUniverseEquityMarketCacheFactory>(); this._fixedIncomeFactory = A.Fake <IUniverseFixedIncomeMarketCacheFactory>(); this._tradingHoursService = A.Fake <IMarketTradingHoursService>(); this._logger = new NullLogger <MarkingTheCloseRule>(); this._tradingHistoryLogger = new NullLogger <TradingHistoryStack>(); this._dataRequestSubscriber = A.Fake <IUniverseDataRequestsSubscriber>(); this._equitiesParameters = A.Fake <IMarkingTheCloseEquitiesParameters>(); this._ruleCtx = A.Fake <ISystemProcessOperationRunRuleContext>(); this._alertStream = A.Fake <IUniverseAlertStream>(); }
public void SetUp() { this.currencyConverterService = A.Fake <ICurrencyConverterService>(); _universeMarketCacheFactory = A.Fake <IUniverseEquityMarketCacheFactory>(); _universeEquityInterDayCache = A.Fake <IUniverseEquityInterDayCache>(); _universeDataRequestsSubscriber = A.Fake <IUniverseDataRequestsSubscriber>(); A.CallTo(() => _universeMarketCacheFactory.BuildInterday(Engine.Rules.Rules.RuleRunMode.ValidationRun)) .Returns(_universeEquityInterDayCache); _tradingHoursService = A.Fake <IMarketTradingHoursService>(); _operationRunRuleContext = A.Fake <ISystemProcessOperationRunRuleContext>(); _logger = A.Fake <ILogger <HighMarketCapFilter> >(); }
public void Setup() { _orderFilterService = A.Fake <IUniverseEquityOrderFilterService>(); _equityFactory = A.Fake <IUniverseEquityMarketCacheFactory>(); _fixedIncomeFactory = A.Fake <IUniverseFixedIncomeMarketCacheFactory>(); _tradingHoursService = A.Fake <IMarketTradingHoursService>(); this.currencyConverterService = A.Fake <ICurrencyConverterService>(); _logger = A.Fake <ILogger <IHighVolumeRule> >(); _tradingHistoryLogger = A.Fake <ILogger <TradingHistoryStack> >(); _equitiesParameters = A.Fake <IHighVolumeRuleEquitiesParameters>(); _opCtx = A.Fake <ISystemProcessOperationRunRuleContext>(); _alertStream = A.Fake <IUniverseAlertStream>(); _dataRequestSubscriber = A.Fake <IUniverseDataRequestsSubscriber>(); }
/// <summary> /// The build rule. /// </summary> /// <param name="parameters"> /// The parameters. /// </param> /// <param name="ruleContext"> /// The rule context. /// </param> /// <param name="judgementService"> /// The judgement service. /// </param> /// <param name="dataRequestSubscriber"> /// The data request subscriber. /// </param> /// <param name="runMode"> /// The run mode. /// </param> /// <param name="scheduledExecution"> /// The scheduled execution. /// </param> /// <returns> /// The <see cref="IFixedIncomeHighProfitsRule"/>. /// </returns> public IFixedIncomeHighProfitsRule BuildRule( IHighProfitsRuleFixedIncomeParameters parameters, ISystemProcessOperationRunRuleContext ruleContext, IFixedIncomeHighProfitJudgementService judgementService, IUniverseDataRequestsSubscriber dataRequestSubscriber, RuleRunMode runMode, ScheduledExecution scheduledExecution) { var fixedIncomeStreamRule = new FixedIncomeHighProfitsStreamRule( parameters, ruleContext, this.costCalculatorFactory, this.revenueCalculatorFactory, this.exchangeRateProfitCalculator, this.fixedIncomeOrderFilterService, this.equityMarketCacheFactory, this.fixedIncomeCacheFactory, this.marketDataCacheStrategyFactory, dataRequestSubscriber, judgementService, currencyConverterService, runMode, this.logger, this.stackLogger); var fixedIncomeMarketClosureRule = new FixedIncomeHighProfitsMarketClosureRule( parameters, ruleContext, this.costCalculatorFactory, this.revenueCalculatorFactory, this.exchangeRateProfitCalculator, this.fixedIncomeOrderFilterService, this.equityMarketCacheFactory, this.fixedIncomeCacheFactory, this.marketDataCacheStrategyFactory, dataRequestSubscriber, judgementService, currencyConverterService, runMode, this.logger, this.stackLogger); return(new FixedIncomeHighProfitsRule( parameters, fixedIncomeStreamRule, fixedIncomeMarketClosureRule, this.logger)); }
public IHighMarketCapFilter Build(RuleRunMode ruleRunMode, DecimalRangeRuleFilter marketCap, string ruleName, IUniverseDataRequestsSubscriber universeDataRequestsSubscriber, ISystemProcessOperationRunRuleContext operationRunRuleContext) { return(new HighMarketCapFilter( _universeMarketCacheFactory, ruleRunMode, marketCap, _tradingHoursService, operationRunRuleContext, universeDataRequestsSubscriber, this.currencyConverterService, ruleName, _loggerFactory.CreateLogger <HighMarketCapFilter>())); }
public IHighProfitRule Build( IHighProfitsRuleEquitiesParameters equitiesParameters, ISystemProcessOperationRunRuleContext ruleCtxStream, ISystemProcessOperationRunRuleContext ruleCtxMarket, IUniverseDataRequestsSubscriber dataRequestSubscriber, IJudgementService judgementService, ScheduledExecution scheduledExecution) { var runMode = scheduledExecution.IsForceRerun ? RuleRunMode.ForceRun : RuleRunMode.ValidationRun; var stream = new HighProfitStreamRule( equitiesParameters, ruleCtxStream, this._costCalculatorFactory, this._revenueCalculatorFactory, this._exchangeRateProfitCalculator, this._orderFilterService, this._equityMarketCacheFactory, this._fixedIncomeMarketCacheFactory, this._cacheStrategyFactory, dataRequestSubscriber, judgementService, this._currencyConversionService, runMode, this._logger, this._tradingHistoryLogger); var marketClosure = new HighProfitMarketClosureRule( equitiesParameters, ruleCtxMarket, this._costCalculatorFactory, this._revenueCalculatorFactory, this._exchangeRateProfitCalculator, this._orderFilterService, this._equityMarketCacheFactory, this._fixedIncomeMarketCacheFactory, this._cacheStrategyFactory, dataRequestSubscriber, judgementService, this._currencyConversionService, runMode, this._logger, this._tradingHistoryLogger); return(new HighProfitsRule(equitiesParameters, stream, marketClosure, this._logger)); }