/// <summary>
 /// Initializes a new instance of the <see cref="FixedIncomeHighProfitFactory"/> class.
 /// </summary>
 /// <param name="fixedIncomeOrderFilterService">
 /// The fixed income order filter service.
 /// </param>
 /// <param name="equityCacheFactory">
 /// The market cache factory.
 /// </param>
 /// <param name="fixedIncomeCacheFactory">
 /// The market cache factory.
 /// </param>
 /// <param name="marketDataCacheStrategyFactory">
 /// The market data cache strategy factory.
 /// </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="logger">
 /// The logger.
 /// </param>
 /// <param name="stackLogger">
 /// The stack logger.
 /// </param>
 public FixedIncomeHighProfitFactory(
     IUniverseFixedIncomeOrderFilterService fixedIncomeOrderFilterService,
     IUniverseEquityMarketCacheFactory equityCacheFactory,
     IUniverseFixedIncomeMarketCacheFactory fixedIncomeCacheFactory,
     IFixedIncomeMarketDataCacheStrategyFactory marketDataCacheStrategyFactory,
     ICostCalculatorFactory costCalculatorFactory,
     IRevenueCalculatorFactory revenueCalculatorFactory,
     IExchangeRateProfitCalculator exchangeRateProfitCalculator,
     ICurrencyConverterService currencyConverterService,
     ILogger <FixedIncomeHighProfitsRule> logger,
     ILogger <TradingHistoryStack> stackLogger)
 {
     this.fixedIncomeOrderFilterService =
         fixedIncomeOrderFilterService ?? throw new ArgumentNullException(nameof(fixedIncomeOrderFilterService));
     this.equityMarketCacheFactory =
         equityCacheFactory ?? throw new ArgumentNullException(nameof(equityCacheFactory));
     this.fixedIncomeCacheFactory =
         fixedIncomeCacheFactory ?? throw new ArgumentNullException(nameof(fixedIncomeCacheFactory));
     this.marketDataCacheStrategyFactory = marketDataCacheStrategyFactory ?? throw new ArgumentNullException(nameof(marketDataCacheStrategyFactory));
     this.costCalculatorFactory          =
         costCalculatorFactory ?? throw new ArgumentNullException(nameof(costCalculatorFactory));
     this.revenueCalculatorFactory     = revenueCalculatorFactory ?? throw new ArgumentNullException(nameof(revenueCalculatorFactory));
     this.exchangeRateProfitCalculator = exchangeRateProfitCalculator ?? throw new ArgumentNullException(nameof(exchangeRateProfitCalculator));
     this.currencyConverterService     = currencyConverterService ?? throw new ArgumentNullException(nameof(currencyConverterService));
     this.logger      = logger ?? throw new ArgumentNullException(nameof(logger));
     this.stackLogger = stackLogger ?? throw new ArgumentNullException(nameof(stackLogger));
 }
Beispiel #2
0
 /// <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 EquityRuleHighProfitFactory(
     ICostCalculatorFactory costCalculatorFactory,
     IRevenueCalculatorFactory revenueCalculatorFactory,
     IExchangeRateProfitCalculator exchangeRateProfitCalculator,
     IUniverseEquityOrderFilterService orderFilterService,
     IUniverseEquityMarketCacheFactory equityMarketCacheFactory,
     IUniverseFixedIncomeMarketCacheFactory fixedIncomeMarketCacheFactory,
     IEquityMarketDataCacheStrategyFactory cacheStrategyFactory,
     ICurrencyConverterService currencyConversionService,
     ILogger <HighProfitsRule> logger,
     ILogger <TradingHistoryStack> tradingHistoryLogger)
 {
     this._costCalculatorFactory =
         costCalculatorFactory ?? throw new ArgumentNullException(nameof(costCalculatorFactory));
     this._revenueCalculatorFactory = revenueCalculatorFactory
                                      ?? throw new ArgumentNullException(nameof(revenueCalculatorFactory));
     this._exchangeRateProfitCalculator = exchangeRateProfitCalculator
                                          ?? throw new ArgumentNullException(
                                                    nameof(exchangeRateProfitCalculator));
     this._equityMarketCacheFactory =
         equityMarketCacheFactory ?? throw new ArgumentNullException(nameof(equityMarketCacheFactory));
     this._fixedIncomeMarketCacheFactory =
         fixedIncomeMarketCacheFactory ?? throw new ArgumentNullException(nameof(fixedIncomeMarketCacheFactory));
     this._cacheStrategyFactory =
         cacheStrategyFactory ?? throw new ArgumentNullException(nameof(cacheStrategyFactory));
     this._logger = logger ?? throw new ArgumentNullException(nameof(logger));
     this._tradingHistoryLogger =
         tradingHistoryLogger ?? throw new ArgumentNullException(nameof(tradingHistoryLogger));
     this._orderFilterService =
         orderFilterService ?? throw new ArgumentNullException(nameof(orderFilterService));
     this._currencyConversionService = currencyConversionService ?? throw new ArgumentNullException(nameof(currencyConversionService));
 }
Beispiel #4
0
        /// <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));
        }
Beispiel #5
0
 public void Setup()
 {
     this.fixedIncomeOrderFilterService  = A.Fake <IUniverseFixedIncomeOrderFilterService>();
     this.equityMarketCacheFactory       = A.Fake <IUniverseEquityMarketCacheFactory>();
     this.fixedIncomeMarketCacheFactory  = A.Fake <IUniverseFixedIncomeMarketCacheFactory>();
     this.marketDataCacheStrategyFactory = A.Fake <IFixedIncomeMarketDataCacheStrategyFactory>();
     this.costCalculatorFactory          = A.Fake <ICostCalculatorFactory>();
     this.revenueCalculatorFactory       = A.Fake <IRevenueCalculatorFactory>();
     this.exchangeRateProfitCalculator   = A.Fake <IExchangeRateProfitCalculator>();
     this.logger                   = A.Fake <ILogger <FixedIncomeHighProfitsRule> >();
     this.stackLogger              = A.Fake <ILogger <TradingHistoryStack> >();
     this.parameters               = A.Fake <IHighProfitsRuleFixedIncomeParameters>();
     this.ruleContext              = A.Fake <ISystemProcessOperationRunRuleContext>();
     this.judgementService         = A.Fake <IFixedIncomeHighProfitJudgementService>();
     this.dataRequestSubscriber    = A.Fake <IUniverseDataRequestsSubscriber>();
     this.currencyConverterService = A.Fake <ICurrencyConverterService>();
     this.runMode                  = RuleRunMode.ValidationRun;
     this.scheduledExecution       = new ScheduledExecution();
 }
        public void Setup()
        {
            this._orderFilterService            = A.Fake <IUniverseEquityOrderFilterService>();
            this._costCalculatorFactory         = A.Fake <ICostCalculatorFactory>();
            this._revenueCalculatorFactory      = A.Fake <IRevenueCalculatorFactory>();
            this._exchangeRateProfitCalculator  = A.Fake <IExchangeRateProfitCalculator>();
            this._equityMarketCacheFactory      = A.Fake <IUniverseEquityMarketCacheFactory>();
            this._fixedIncomeMarketCacheFactory = A.Fake <IUniverseFixedIncomeMarketCacheFactory>();
            this._cacheStrategyFactory          = A.Fake <IEquityMarketDataCacheStrategyFactory>();
            this._judgementService         = A.Fake <IJudgementService>();
            this._logger                   = new NullLogger <HighProfitsRule>();
            this._tradingHistoryLogger     = new NullLogger <TradingHistoryStack>();
            this._currencyConverterService = A.Fake <ICurrencyConverterService>();

            this._equitiesParameters    = A.Fake <IHighProfitsRuleEquitiesParameters>();
            this._ruleCtxStream         = A.Fake <ISystemProcessOperationRunRuleContext>();
            this._ruleCtxMarket         = A.Fake <ISystemProcessOperationRunRuleContext>();
            this._dataRequestSubscriber = A.Fake <IUniverseDataRequestsSubscriber>();
            this._scheduledExecution    = new ScheduledExecution();
        }
        /// <summary>
        /// The test setup.
        /// </summary>
        private void Setup()
        {
            this.tradingHoursService = A.Fake <IMarketTradingHoursService>();

            A.CallTo(() => this.tradingHoursService.GetTradingHoursForMic("XLON")).Returns(
                new TradingHours
            {
                CloseOffsetInUtc = TimeSpan.FromHours(16),
                IsValid          = true,
                Mic             = "XLON",
                OpenOffsetInUtc = TimeSpan.FromHours(8)
            });

            A.CallTo(() => this.tradingHoursService.GetTradingHoursForMic("NASDAQ")).Returns(
                new TradingHours
            {
                CloseOffsetInUtc = TimeSpan.FromHours(23),
                IsValid          = true,
                Mic             = "NASDAQ",
                OpenOffsetInUtc = TimeSpan.FromHours(15)
            });

            this.equityMarketCacheFactory = new UniverseEquityMarketCacheFactory(
                new StubRuleRunDataRequestRepository(),
                new StubRuleRunDataRequestRepository(),
                new NullLogger <UniverseEquityMarketCacheFactory>());

            this.fixedIncomeMarketCacheFactory = new UniverseFixedIncomeMarketCacheFactory(
                new StubRuleRunDataRequestRepository(),
                new StubRuleRunDataRequestRepository(),
                new NullLogger <UniverseFixedIncomeMarketCacheFactory>());

            this.universeOrderFilterService = A.Fake <IUniverseEquityOrderFilterService>();
            this.logger                = new NullLogger <HighProfitsRule>();
            this.tradingLogger         = new NullLogger <TradingHistoryStack>();
            this.ruleContext           = A.Fake <ISystemProcessOperationRunRuleContext>();
            this.dataRequestSubscriber = A.Fake <IUniverseDataRequestsSubscriber>();

            this.exchangeRateProfitCalculator   = A.Fake <IExchangeRateProfitCalculator>();
            this.marketDataCacheStrategyFactory = new EquityMarketDataCacheStrategyFactory();

            this.costCalculatorFactory = new CostCalculatorFactory(
                new CurrencyConverterService(
                    this.exchangeRateSelection.ExchangeRateRepository,
                    new NullLogger <CurrencyConverterService>()),
                new NullLogger <CostCalculator>(),
                new NullLogger <CostCurrencyConvertingCalculator>());

            this.revenueCalculatorFactory = new RevenueCalculatorFactory(
                this.tradingHoursService,
                new CurrencyConverterService(
                    this.exchangeRateSelection.ExchangeRateRepository,
                    new NullLogger <CurrencyConverterService>()),
                new NullLogger <RevenueCurrencyConvertingCalculator>(),
                new NullLogger <RevenueCalculator>());

            this.equityRuleHighProfitFactory = new EquityRuleHighProfitFactory(
                this.costCalculatorFactory,
                this.revenueCalculatorFactory,
                this.exchangeRateProfitCalculator,
                this.universeOrderFilterService,
                this.equityMarketCacheFactory,
                this.fixedIncomeMarketCacheFactory,
                this.marketDataCacheStrategyFactory,
                new CurrencyConverterService(
                    this.exchangeRateSelection.ExchangeRateRepository,
                    new NullLogger <CurrencyConverterService>()),
                this.logger,
                this.tradingLogger);

            this.judgementRepository  = A.Fake <IJudgementRepository>();
            this.ruleViolationService = A.Fake <IRuleViolationService>();

            this.judgementService = new JudgementService(
                this.judgementRepository,
                this.ruleViolationService,
                new HighProfitJudgementMapper(new NullLogger <HighProfitJudgementMapper>()),
                new FixedIncomeHighProfitJudgementMapper(new NullLogger <FixedIncomeHighProfitJudgementMapper>()),
                new FixedIncomeHighVolumeJudgementMapper(new NullLogger <FixedIncomeHighVolumeJudgementMapper>()),
                new NullLogger <JudgementService>());

            this.exchangeRateProfitCalculator   = A.Fake <IExchangeRateProfitCalculator>();
            this.marketDataCacheStrategyFactory = new EquityMarketDataCacheStrategyFactory();
        }