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