public RequiredLevyAmountFundingSourceService(
     IPaymentProcessor processor,
     IMapper mapper,
     IDataCache <CalculatedRequiredLevyAmount> requiredPaymentsCache,
     ILevyFundingSourceRepository levyFundingSourceRepository,
     ILevyBalanceService levyBalanceService,
     IPaymentLogger paymentLogger,
     IDataCache <bool> monthEndCache,
     IDataCache <LevyAccountModel> levyAccountCache,
     IDataCache <List <EmployerProviderPriorityModel> > employerProviderPriorities,
     IDataCache <List <string> > refundSortKeysCache,
     IDataCache <List <TransferPaymentSortKeyModel> > transferPaymentSortKeysCache,
     IDataCache <List <RequiredPaymentSortKeyModel> > requiredPaymentSortKeysCache,
     IGenerateSortedPaymentKeys generateSortedPaymentKeys)
 {
     this.processor                    = processor ?? throw new ArgumentNullException(nameof(processor));
     this.mapper                       = mapper ?? throw new ArgumentNullException(nameof(mapper));
     this.requiredPaymentsCache        = requiredPaymentsCache ?? throw new ArgumentNullException(nameof(requiredPaymentsCache));
     this.levyFundingSourceRepository  = levyFundingSourceRepository ?? throw new ArgumentNullException(nameof(levyFundingSourceRepository));
     this.levyBalanceService           = levyBalanceService ?? throw new ArgumentNullException(nameof(levyBalanceService));
     this.paymentLogger                = paymentLogger ?? throw new ArgumentNullException(nameof(paymentLogger));
     this.monthEndCache                = monthEndCache ?? throw new ArgumentNullException(nameof(monthEndCache));
     this.levyAccountCache             = levyAccountCache ?? throw new ArgumentNullException(nameof(levyAccountCache));
     this.employerProviderPriorities   = employerProviderPriorities ?? throw new ArgumentNullException(nameof(employerProviderPriorities));
     this.refundSortKeysCache          = refundSortKeysCache ?? throw new ArgumentNullException(nameof(refundSortKeysCache));
     this.transferPaymentSortKeysCache = transferPaymentSortKeysCache ?? throw new ArgumentNullException(nameof(transferPaymentSortKeysCache));
     this.requiredPaymentSortKeysCache = requiredPaymentSortKeysCache ?? throw new ArgumentNullException(nameof(requiredPaymentSortKeysCache));
     this.generateSortedPaymentKeys    = generateSortedPaymentKeys ?? throw new ArgumentNullException(nameof(generateSortedPaymentKeys));
 }
        public void Setup()
        {
            mocker = AutoMock.GetStrict();
            employerProviderPrioritiesMock   = mocker.Mock <IDataCache <List <EmployerProviderPriorityModel> > >();
            refundSortKeysCacheMock          = mocker.Mock <IDataCache <List <string> > >();
            transferPaymentSortKeysCacheMock = mocker.Mock <IDataCache <List <TransferPaymentSortKeyModel> > >();
            requiredPaymentSortKeysCacheMock = mocker.Mock <IDataCache <List <RequiredPaymentSortKeyModel> > >();

            sut = mocker.Create <GenerateSortedPaymentKeys>();
        }
Esempio n. 3
0
        protected override async Task OnActivateAsync()
        {
            using (var operation = telemetry.StartOperation("LevyFundedService.OnActivateAsync", $"{Id}_{Guid.NewGuid():N}"))
            {
                var stopwatch = Stopwatch.StartNew();
                //TODO: Use DI
                actorCache = new ActorReliableCollectionCache <bool>(StateManager);
                employerProviderPriorities = new ReliableCollectionCache <List <EmployerProviderPriorityModel> >(StateManager);
                requiredPaymentsCache      = new ReliableCollectionCache <CalculatedRequiredLevyAmount>(StateManager);
                monthEndCache                = new ReliableCollectionCache <bool>(StateManager);
                levyAccountCache             = new ReliableCollectionCache <LevyAccountModel>(StateManager);
                refundSortKeysCache          = new ReliableCollectionCache <List <string> >(StateManager);
                transferPaymentSortKeysCache = new ReliableCollectionCache <List <TransferPaymentSortKeyModel> >(StateManager);
                requiredPaymentSortKeysCache = new ReliableCollectionCache <List <RequiredPaymentSortKeyModel> >(StateManager);

                generateSortedPaymentKeys = new GenerateSortedPaymentKeys(
                    employerProviderPriorities,
                    refundSortKeysCache,
                    transferPaymentSortKeysCache,
                    requiredPaymentSortKeysCache
                    );

                fundingSourceService = new RequiredLevyAmountFundingSourceService(
                    lifetimeScope.Resolve <IPaymentProcessor>(),
                    lifetimeScope.Resolve <IMapper>(),
                    requiredPaymentsCache,
                    lifetimeScope.Resolve <ILevyFundingSourceRepository>(),
                    lifetimeScope.Resolve <ILevyBalanceService>(),
                    lifetimeScope.Resolve <IPaymentLogger>(),
                    monthEndCache,
                    levyAccountCache,
                    employerProviderPriorities,
                    refundSortKeysCache,
                    transferPaymentSortKeysCache,
                    requiredPaymentSortKeysCache,
                    generateSortedPaymentKeys
                    );

                await Initialise().ConfigureAwait(false);

                await base.OnActivateAsync().ConfigureAwait(false);

                TrackInfrastructureEvent("LevyFundedService.OnActivateAsync", stopwatch);
                telemetry.StopOperation(operation);
            }
        }