/// <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));
}
