public async Task Commands_Are_Created_Using_Dc_JobId()
        {
            providers.Add(1234);
            var periodEndStopped = new PeriodEndStoppedEvent
            {
                CollectionPeriod = new CollectionPeriod {
                    AcademicYear = 1920, Period = 10
                },
                JobId = 123
            };
            var service  = mocker.Create <PeriodEndService>();
            var commands = await service.GenerateProviderMonthEndCommands(periodEndStopped);

            commands.Count.Should().Be(1);
            commands.Any(command => command.JobId == 123).Should().BeTrue();
        }
        public async Task Generates_Provider_Period_End_Command_For_All_Providers()
        {
            providers.Add(1234);
            providers.Add(5678);
            providers.Add(9012);
            var periodEndStopped = new PeriodEndStoppedEvent
            {
                CollectionPeriod = new CollectionPeriod {
                    AcademicYear = 1920, Period = 10
                },
                JobId = 123
            };
            var service  = mocker.Create <PeriodEndService>();
            var commands = await service.GenerateProviderMonthEndCommands(periodEndStopped);

            commands.Count.Should().Be(3);
            commands.Any(command => command.Ukprn == 1234).Should().BeTrue();
            commands.Any(command => command.Ukprn == 5678).Should().BeTrue();
            commands.Any(command => command.Ukprn == 9012).Should().BeTrue();
        }
        public async Task SendPeriodEndStoppedEvent_ApprovalsServiceIsReinstalled()
        {
            var messageSession = await MessageSessionBuilder.BuildAsync();

            var serviceStatus = await ServiceFabricManager.IsApprovalsServiceRunning();

            serviceStatus.Should().BeFalse("Approvals service is running prior to test start");

            var periodEndEvent = new PeriodEndStoppedEvent();
            await messageSession.Publish(periodEndEvent).ConfigureAwait(false);

            var result = await new TimeService()
                         .WaitForBoolean(async() =>
                                         await ServiceFabricManager.IsApprovalsServiceRunning(),
                                         true);

            if (result)
            {
                return;
            }

            Assert.Fail("Approvals service is not running 15s after sending message");
        }
        public async Task StoreCollectionPeriod(PeriodEndStoppedEvent message)
        {
            if (context.CollectionPeriod.Any(x => x.AcademicYear == message.CollectionPeriod.AcademicYear && x.Period == message.CollectionPeriod.Period))
            {
                return;
            }

            var referenceDataValidationDate = await GetReferenceDataValidationDate(message.CollectionPeriod.AcademicYear, message.CollectionPeriod.Period);

            if (referenceDataValidationDate == null)
            {
                throw new InvalidOperationException($"Failed to find successful PeriodEndSubmissionWindowValidationJob for academic year: {message.CollectionPeriod.AcademicYear} and period: {message.CollectionPeriod.Period} with an EndTime set");
            }

            await context.CollectionPeriod.AddAsync(new CollectionPeriodModel
            {
                AcademicYear   = message.CollectionPeriod.AcademicYear,
                Period         = message.CollectionPeriod.Period,
                CompletionDate = message.EventTime.DateTime,
                ReferenceDataValidationDate = referenceDataValidationDate
            });

            await context.SaveChanges();
        }
Esempio n. 5
0
        public async Task <List <ProcessProviderMonthEndCommand> > GenerateProviderMonthEndCommands(PeriodEndStoppedEvent message)
        {
            logger.LogInfo($"now building Provider Period End Commands for collection period: {message.CollectionPeriod.Period:00}-{message.CollectionPeriod.AcademicYear:0000}, job: {message.JobId}");
            var providers = await repository.GetMonthEndProviders(message.CollectionPeriod, CancellationToken.None)
                            .ConfigureAwait(false);

            var commands = new List <ProcessProviderMonthEndCommand>();

            foreach (var provider in providers)
            {
                logger.LogDebug($"Creating period end command for provider: {provider}");
                commands.Add(new ProcessProviderMonthEndCommand
                {
                    Ukprn            = provider,
                    CollectionPeriod = message.CollectionPeriod,
                    JobId            = message.JobId
                });
            }
            logger.LogInfo($"Finished creating the provider period end events for collection period: {message.CollectionPeriod.Period:00}-{message.CollectionPeriod.AcademicYear:0000}, job: {message.JobId}");
            return(commands);
        }
        public async Task <List <ProcessProviderMonthEndAct1CompletionPaymentCommand> > GenerateProviderMonthEndAct1CompletionPaymentCommands(PeriodEndStoppedEvent message)
        {
            logger.LogInfo($"Building Act1 Completion Payment Events for collection period: {message.CollectionPeriod.Period:00}-{message.CollectionPeriod.AcademicYear:0000}, job: {message.JobId}");

            var providers = await repository.GetProvidersWithAct1CompletionPayments(message.CollectionPeriod).ConfigureAwait(false);

            var commands = providers
                           .Select(ukprn => new ProcessProviderMonthEndAct1CompletionPaymentCommand
            {
                Ukprn            = ukprn,
                CollectionPeriod = message.CollectionPeriod,
                JobId            = message.JobId
            }).ToList();

            logger.LogInfo($"Finished creating provider Act1 Completion Payment events for collection period: {message.CollectionPeriod.Period:00}-{message.CollectionPeriod.AcademicYear:0000}, job: {message.JobId}");

            return(commands);
        }