public void Before_each_test()
        {
            _logger    = new Mock <ILogger <UpdateOrganisationApplicationDeterminedDateHandler> >();
            _validator = new Mock <IOrganisationValidator>();
            _validator.Setup(x => x.IsValidApplicationDeterminedDate(It.IsAny <DateTime?>())).Returns(true);
            _repository = new Mock <IOrganisationRepository>();
            _repository.Setup(x => x.GetApplicationDeterminedDate(It.IsAny <Guid>())).ReturnsAsync(DateTime.Today).Verifiable();

            _updateOrganisationRepository = new Mock <IUpdateOrganisationRepository>();
            _updateOrganisationRepository.Setup(x => x.UpdateApplicationDeterminedDate(It.IsAny <Guid>(), It.IsAny <DateTime>(), It.IsAny <string>())).ReturnsAsync(true).Verifiable();
            _updateOrganisationRepository.Setup(x => x.WriteFieldChangesToAuditLog(It.IsAny <AuditData>())).ReturnsAsync(true).Verifiable();
            _auditLogService = new Mock <IAuditLogService>();
            _auditLogService.Setup(x => x.CreateAuditData(It.IsAny <Guid>(), It.IsAny <string>()))
            .Returns(new AuditData {
                FieldChanges = new List <AuditLogEntry>()
            });
            _auditLogService.Setup(x => x.AuditApplicationDeterminedDate(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <DateTime>()))
            .Returns(new AuditData {
                FieldChanges = new List <AuditLogEntry>()
            });

            _handler = new UpdateOrganisationApplicationDeterminedDateHandler(_logger.Object, _validator.Object,
                                                                              _updateOrganisationRepository.Object, _auditLogService.Object);
            _request = new UpdateOrganisationApplicationDeterminedDateRequest
            {
                OrganisationId            = Guid.NewGuid(),
                ApplicationDeterminedDate = DateTime.Today,
                UpdatedBy = "test"
            };
        }
        public void Handler_writes_updated_application_determined_date_and_audit_log_entry_to_database()
        {
            var request = new UpdateOrganisationApplicationDeterminedDateRequest
            {
                ApplicationDeterminedDate = DateTime.Today.AddDays(-2),
                OrganisationId            = Guid.NewGuid(),
                UpdatedBy = "unit test"
            };


            var fieldChanges = new List <AuditLogEntry>();

            fieldChanges.Add(new AuditLogEntry {
                FieldChanged = AuditLogField.ApplicationDeterminedDate, NewValue = DateTime.Today.AddDays(-2).ToShortDateString(), PreviousValue = DateTime.Today.ToShortDateString()
            });
            _auditLogService.Setup(x => x.AuditApplicationDeterminedDate(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <DateTime>()))
            .Returns(new AuditData {
                FieldChanges = fieldChanges
            });

            var result = _handler.Handle(request, new CancellationToken()).GetAwaiter().GetResult();

            result.Should().BeTrue();

            _auditLogService.Verify(x => x.AuditApplicationDeterminedDate(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <DateTime>()), Times.Once);
            _updateOrganisationRepository.Verify(x => x.UpdateApplicationDeterminedDate(It.IsAny <Guid>(), It.IsAny <DateTime>(), It.IsAny <string>()), Times.Once);
            _updateOrganisationRepository.Verify(x => x.WriteFieldChangesToAuditLog(It.IsAny <AuditData>()), Times.Once);
        }
Esempio n. 3
0
        public async Task <bool> RecordOutcome(Guid applicationId, bool?approveGateway, bool?approveModeration, OversightReviewStatus outcome, string userId, string userName, string internalComments, string externalComments)
        {
            _logger.LogInformation($"Recording an oversight outcome of {outcome} for application {applicationId}");

            var registrationDetails = await _applicationApiClient.GetRegistrationDetails(applicationId);

            var registerStatus = await _registerApiClient.GetOrganisationRegisterStatus(new GetOrganisationRegisterStatusRequest { UKPRN = registrationDetails.UKPRN });

            ValidateStatusAgainstExistingStatus(outcome, registerStatus, registrationDetails.UKPRN);

            var updateOutcomeCommand = new RecordOversightOutcomeCommand
            {
                ApplicationId     = applicationId,
                ApproveGateway    = approveGateway,
                ApproveModeration = approveModeration,
                OversightStatus   = outcome,
                UserId            = userId,
                UserName          = userName,
                InternalComments  = internalComments,
                ExternalComments  = externalComments
            };

            var updateOutcomeSuccess = await _applicationApiClient.RecordOutcome(updateOutcomeCommand);

            if (!updateOutcomeSuccess)
            {
                return(false);
            }

            if (outcome == OversightReviewStatus.Successful)
            {
                var request = BuildCreateOrganisationRequest(updateOutcomeCommand, registrationDetails);

                var updateRegisterResult = await _registerApiClient.CreateOrganisation(request);

                return(updateRegisterResult);
            }

            if (outcome == OversightReviewStatus.SuccessfulAlreadyActive ||
                outcome == OversightReviewStatus.SuccessfulFitnessForFunding)
            {
                var updateDeterminedDateRequest = new UpdateOrganisationApplicationDeterminedDateRequest
                {
                    ApplicationDeterminedDate = DateTime.UtcNow.Date,
                    LegalName      = registrationDetails.LegalName,
                    OrganisationId = registerStatus.OrganisationId.Value,
                    UpdatedBy      = userId
                };

                await _registerApiClient.UpdateApplicationDeterminedDate(updateDeterminedDateRequest);
            }

            return(updateOutcomeSuccess);
        }
        public void Handler_does_not_update_database_if_company_number_unchanged()
        {
            var request = new UpdateOrganisationApplicationDeterminedDateRequest
            {
                ApplicationDeterminedDate = DateTime.Today,
                OrganisationId            = Guid.NewGuid(),
                UpdatedBy = "unit test"
            };

            var result = _handler.Handle(request, new CancellationToken()).Result;

            result.Should().BeFalse();

            _auditLogService.Verify(x => x.AuditApplicationDeterminedDate(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <DateTime>()), Times.Once);
            _updateOrganisationRepository.Verify(x => x.UpdateApplicationDeterminedDate(It.IsAny <Guid>(), It.IsAny <DateTime>(), It.IsAny <string>()), Times.Never);
            _updateOrganisationRepository.Verify(x => x.WriteFieldChangesToAuditLog(It.IsAny <AuditData>()), Times.Never);
        }
        public void Handler_does_not_update_database_if_application_determined_date_invalid()
        {
            _validator.Setup(x => x.IsValidApplicationDeterminedDate(It.IsAny <DateTime?>())).Returns(false);
            var request = new UpdateOrganisationApplicationDeterminedDateRequest
            {
                ApplicationDeterminedDate = DateTime.Today.AddDays(1),
                OrganisationId            = Guid.NewGuid(),
                UpdatedBy = "unit test"
            };

            Func <Task> result = async() => await
                                 _handler.Handle(request, new CancellationToken());

            result.Should().Throw <BadRequestException>();

            _auditLogService.Verify(x => x.AuditApplicationDeterminedDate(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <DateTime>()), Times.Never);
            _updateOrganisationRepository.Verify(x => x.UpdateApplicationDeterminedDate(It.IsAny <Guid>(), It.IsAny <DateTime>(), It.IsAny <string>()), Times.Never);
            _updateOrganisationRepository.Verify(x => x.WriteFieldChangesToAuditLog(It.IsAny <AuditData>()), Times.Never);
        }
 public async Task <IActionResult> UpdateApplicationDeterminedDate([FromBody] UpdateOrganisationApplicationDeterminedDateRequest request)
 {
     return(Ok(await _mediator.Send(request)));
 }
        public async Task <bool> UpdateApplicationDeterminedDate(UpdateOrganisationApplicationDeterminedDateRequest request)
        {
            var result = await Put($"/api/v1/updateorganisation/applicationDeterminedDate", request);

            return(await Task.FromResult(result == HttpStatusCode.OK));
        }