public static string GetLabel(this OversightReviewStatus status)
{
switch (status)
{
case OversightReviewStatus.Successful:
case OversightReviewStatus.SuccessfulAlreadyActive:
case OversightReviewStatus.SuccessfulFitnessForFunding:
return("Successful");
case OversightReviewStatus.InProgress:
return("In progress");
case OversightReviewStatus.Rejected:
return("Rejected");
case OversightReviewStatus.Removed:
return("Removed");
case OversightReviewStatus.Unsuccessful:
return("Unsuccessful");
case OversightReviewStatus.Withdrawn:
return("Withdrawn");
default:
return("");
}
}
public static string GetCssClass(this OversightReviewStatus status)
{
switch (status)
{
case OversightReviewStatus.Successful:
case OversightReviewStatus.SuccessfulAlreadyActive:
case OversightReviewStatus.SuccessfulFitnessForFunding:
return("govuk-tag das-tag--solid-green");
case OversightReviewStatus.InProgress:
return("govuk-tag das-tag");
case OversightReviewStatus.Rejected:
return("govuk-tag das-tag--solid-brown");
case OversightReviewStatus.Removed:
return("govuk-tag govuk-tag--inactive");
case OversightReviewStatus.Unsuccessful:
return("govuk-tag das-tag--solid-red");
case OversightReviewStatus.Withdrawn:
return("govuk-tag govuk-tag--inactive");
default:
return("");
}
}
public void OversightOutcomeValidator_returns_error_when_status_is_empty(OversightReviewStatus oversightStatus, string approveGateway, string approveModeration, bool errorsExpected)
{
var request = new OutcomePostRequest
{
OversightStatus = oversightStatus,
ApproveGateway = approveGateway,
ApproveModeration = approveModeration,
UnsuccessfulText = oversightStatus == OversightReviewStatus.Unsuccessful ? "comments" : null
};
var result = _validator.Validate(request, options => options.IncludeRuleSets(OutcomePostRequestValidator.RuleSets.Default));
Assert.AreEqual(errorsExpected, !result.IsValid);
}
Application_status_and_register_updated_for_a_successful_already_active_or_fitness_for_funding_oversight_review(
OversightReviewStatus status)
{
var applicationDetails = new ApplicationDetails
{
ApplicationId = _applicationId,
GatewayReviewStatus = GatewayReviewStatus.Pass
};
_applicationApiClient.Setup(x => x.GetApplicationDetails(_applicationId)).ReturnsAsync(applicationDetails);
await _orchestrator.RecordOutcome(_applicationId, false, false, status, UserId, UserName, InternalComments, ExternalComments);
_applicationApiClient.Verify(x => x.RecordOutcome(It.Is <RecordOversightOutcomeCommand>(y => y.ApplicationId == _applicationId)), Times.Once);
_roatpRegisterApiClient.Verify(x => x.UpdateOrganisation(It.Is <UpdateOrganisationRequest>(y => y.OrganisationId == _registerStatus.OrganisationId)), Times.Once);
}
public async Task TestShowAppealLink(OversightReviewStatus status, bool expectedShowAppealLink)
{
_apiClient.Setup(x => x.GetApplicationDetails(_applicationId))
.ReturnsAsync(() => new ApplicationDetails());
_apiClient.Setup(x => x.GetOversightReview(_applicationId))
.ReturnsAsync(() => new GetOversightReviewResponse
{
Status = status
});
_apiClient.Setup(x => x.GetAppeal(_applicationId, _oversightReviewId))
.ReturnsAsync(() => null);
var result = await _orchestrator.GetOversightDetailsViewModel(_applicationId, null);
Assert.AreEqual(expectedShowAppealLink, result.ShowAppealLink);
}
private void ValidateStatusAgainstExistingStatus(OversightReviewStatus outcome, OrganisationRegisterStatus registerStatus, string ukprn)
{
if (outcome == OversightReviewStatus.Successful)
{
if (registerStatus.UkprnOnRegister)
{
throw new InvalidOperationException($"Unable to register successful provider {ukprn} - already on register");
}
}
if (outcome == OversightReviewStatus.SuccessfulAlreadyActive || outcome == OversightReviewStatus.SuccessfulFitnessForFunding)
{
if (!registerStatus.UkprnOnRegister)
{
throw new InvalidOperationException(
$"Unable to update determined date for provider {ukprn} - provider not on register");
}
}
}
public void OversightOutcomeValidator_returns_expected_error_message_when_status_is_empty(OversightReviewStatus oversightStatus)
{
var request = new OutcomePostRequest
{
SelectedOption = OutcomePostRequest.SubmitOption.SubmitOutcome,
OversightStatus = oversightStatus,
ApproveGateway = ApprovalStatus.Approve,
ApproveModeration = ApprovalStatus.Approve
};
var result = _validator.Validate(request, options => options.IncludeRuleSets(OutcomePostRequestValidator.RuleSets.Default));
Assert.IsTrue(result.Errors.Any(x => x.PropertyName == "OversightStatus" && x.ErrorMessage == "Select the overall outcome of this application"));
}
public async Task Application_shows_removed_page_if_application_removed_and_oversight_status_is_not_removed(OversightReviewStatus oversightStatus)
{
var model = new ApplicationSummaryViewModel
{
ApplicationStatus = ApplicationStatus.Removed,
OversightReviewStatus = oversightStatus,
ApplicationDeterminedDate = DateTime.Today,
AppealRequiredByDate = DateTime.Today.AddDays(10)
};
_outcomeService.Setup(x => x.BuildApplicationSummaryViewModel(_applicationId, It.IsAny <string>())).ReturnsAsync(model);
var result = await _controller.ProcessApplicationStatus(_applicationId);
var viewResult = result as ViewResult;
viewResult.Should().NotBeNull();
viewResult.ViewName.Should().Contain("ApplicationSubmitted.cshtml");
}
public async Task Application_shows_active_with_view_appropriate_to_oversight_or_appeal_status(OversightReviewStatus oversightReviewStatus, string appealStatus, string expectedView)
{
var model = new ApplicationSummaryViewModel
{
ApplicationStatus = ApplicationStatus.Successful,
OversightReviewStatus = oversightReviewStatus,
AppealStatus = appealStatus
};
_outcomeService.Setup(x => x.BuildApplicationSummaryViewModel(_applicationId, It.IsAny <string>())).ReturnsAsync(model);
var result = await _controller.ProcessApplicationStatus(_applicationId);
var viewResult = result as ViewResult;
viewResult.Should().NotBeNull();
viewResult.ViewName.Should().Contain(expectedView);
}
public async Task Application_shows_approved_supporting_page_with_formatted_amount_that_matches_oversight_and_appeal_statuses(OversightReviewStatus oversightReviewStatus, string appealStatus, string expectedView, int subcontractorLimit, string subcontractLimitFormatted)
{
var supportingRouteId = Domain.Roatp.ApplicationRoute.SupportingProviderApplicationRoute;
var model = new ApplicationSummaryViewModel
{
ApplicationStatus = ApplicationStatus.Successful,
ApplicationRouteId = supportingRouteId.ToString(),
SubcontractingLimit = subcontractorLimit,
OversightReviewStatus = oversightReviewStatus,
AppealStatus = appealStatus
};
_outcomeService.Setup(x => x.BuildApplicationSummaryViewModel(_applicationId, It.IsAny <string>())).ReturnsAsync(model);
var result = await _controller.ProcessApplicationStatus(_applicationId);
var viewResult = result as ViewResult;
viewResult.Should().NotBeNull();
viewResult.ViewName.Should().Contain(expectedView);
var modelReturned = viewResult.Model as ApplicationSummaryViewModel;
modelReturned.SubcontractingLimit.Should().Be(subcontractorLimit);
modelReturned.SubcontractingLimitFormatted.Should().Be(subcontractLimitFormatted);
}
public async Task Handler_sends_application_updated_email_for_all_status_changes(OversightReviewStatus newOversightReviewStatus)
{
var applicationId = Guid.NewGuid();
var command = new RecordOversightOutcomeCommand
{
ApplicationId = applicationId,
OversightStatus = newOversightReviewStatus,
UserName = "******",
UserId = "testUser",
InternalComments = "testInternalComments",
ExternalComments = "testExternalComments"
};
var existingOversightReview = new OversightReview
{
Status = OversightReviewStatus.InProgress
};
var oversightReviewRepository = new Mock <IOversightReviewRepository>();
oversightReviewRepository.Setup(x => x.Update(It.IsAny <OversightReview>()));
oversightReviewRepository.Setup(x => x.GetByApplicationId(It.IsAny <Guid>())).ReturnsAsync(() => existingOversightReview);
var repository = new Mock <IApplicationRepository>();
repository.Setup(x => x.GetApplication(command.ApplicationId)).ReturnsAsync(() => new Domain.Entities.Apply
{
ApplicationId = command.ApplicationId, Status = ApplicationStatus.Submitted
});
var applicationUpdatedEmailService = new Mock <IApplicationUpdatedEmailService>();
var logger = new Mock <ILogger <RecordOversightOutcomeHandler> >();
var handler = new RecordOversightOutcomeHandler(logger.Object, oversightReviewRepository.Object, repository.Object, Mock.Of <IAuditService>(), applicationUpdatedEmailService.Object, Mock.Of <IUnitOfWork>());
await handler.Handle(command, new CancellationToken());
applicationUpdatedEmailService.Verify(x => x.SendEmail(It.Is <Guid>(id => id == command.ApplicationId)), Times.Once);
}
public async Task GetOutcome_returns_applications_view_when_oversight_status_is_successful_or_unsuccessful(OversightReviewStatus status)
{
_oversightOrchestrator.Setup(x => x.GetOversightDetailsViewModel(_applicationDetailsApplicationId, null)).Throws <InvalidStateException>();
var request = new OutcomeRequest {
ApplicationId = _applicationDetailsApplicationId
};
var result = await _controller.Outcome(request) as RedirectToActionResult;
Assert.That(result, Is.Not.Null);
Assert.That(result.ActionName, Is.EqualTo("Applications"));
}
public void Successful_already_active_or_fitness_for_funding_oversight_review_for_provider_not_already_on_register_throws_exception(OversightReviewStatus status)
{
_registerStatus.UkprnOnRegister = false;
Assert.ThrowsAsync <InvalidOperationException>(async() =>
await _orchestrator.RecordOutcome(_applicationId, false, false, status, UserId, UserName, InternalComments, ExternalComments));
}
public void Handle_Throws_If_Oversight_Review_Is_Not_Unsuccessful_or_Removed(OversightReviewStatus status)
{
_oversightReview.Status = status;
Assert.ThrowsAsync <InvalidOperationException>(() => _handler.Handle(_command, CancellationToken.None));
}
public async Task ConfirmWithdrawApplication_When_oversight_performed_returns_to_ViewApplication(OversightReviewStatus oversightStatus)
{
var applicationId = Guid.NewGuid();
var viewModel = new RoatpWithdrawApplicationViewModel
{
ApplicationId = applicationId,
ConfirmApplicationAction = HtmlAndCssElements.RadioButtonValueNo,
ErrorMessages = new List <ValidationErrorDetail>()
};
ApplyApiClient.Setup(x => x.GetApplication(applicationId)).ReturnsAsync(new Apply {
ApplicationId = applicationId
});
ApplyApiClient.Setup(x => x.GetOversightDetails(applicationId)).ReturnsAsync(() =>
new ApplicationOversightDetails {
OversightStatus = oversightStatus
});
_withdrawApplicationValidator.Setup(v => v.Validate(viewModel)).ReturnsAsync(new ValidationResponse {
Errors = new List <ValidationErrorDetail>()
});
var result = await _controller.ConfirmWithdrawApplication(applicationId, viewModel);
var viewResult = result as RedirectToActionResult;
Assert.AreEqual(nameof(RoatpGatewayController.ViewApplication), viewResult.ActionName);
Assert.AreEqual("RoatpGateway", viewResult.ControllerName);
}
public void Record_oversight_Throws_Exception_If_Already_Recorded_Unless_InProgress(OversightReviewStatus originalStatus, bool expectThrows)
{
var applicationId = Guid.NewGuid();
var command = new RecordOversightOutcomeCommand
{
ApplicationId = applicationId,
OversightStatus = OversightReviewStatus.Successful,
UserName = "******",
UserId = "testUser",
InternalComments = "testInternalComments",
ExternalComments = "testExternalComments"
};
var existingOversightReview = new OversightReview
{
Status = originalStatus
};
var oversightReviewRepository = new Mock <IOversightReviewRepository>();
oversightReviewRepository.Setup(x => x.Update(It.IsAny <OversightReview>()));
oversightReviewRepository.Setup(x => x.GetByApplicationId(It.IsAny <Guid>())).ReturnsAsync(() => existingOversightReview);
var repository = new Mock <IApplicationRepository>();
repository.Setup(x => x.GetApplication(command.ApplicationId)).ReturnsAsync(() => new Domain.Entities.Apply
{
ApplicationId = command.ApplicationId, Status = ApplicationStatus.Submitted
});
var logger = new Mock <ILogger <RecordOversightOutcomeHandler> >();
var handler = new RecordOversightOutcomeHandler(logger.Object, oversightReviewRepository.Object, repository.Object, Mock.Of <IAuditService>());
if (expectThrows)
{
Assert.ThrowsAsync <InvalidOperationException>(async() => await handler.Handle(command, new CancellationToken()));
}
else
{
Assert.DoesNotThrowAsync(async() => await handler.Handle(command, new CancellationToken()));
}
}
public async Task Record_oversight_outcome_updates_oversight_status_and_determined_date(OversightReviewStatus oversightStatus)
{
var command = new RecordOversightOutcomeCommand
{
OversightStatus = oversightStatus,
ApplicationId = Guid.NewGuid(),
UserId = "User Id",
UserName = "******"
};
_mediator.Setup(x => x.Send(command, It.IsAny <CancellationToken>())).ReturnsAsync(true);
var result = await _controller.RecordOversightOutcome(command);
result.Should().NotBeNull();
result.Value.Should().BeTrue();
}
public async Task Record_oversight_outcome_updates_oversight_status_and_applies_correct_application_status(OversightReviewStatus oversightReviewStatus, string applicationStatus)
{
var command = new RecordOversightOutcomeCommand
{
ApplicationId = Guid.NewGuid(),
OversightStatus = oversightReviewStatus,
UserName = "******",
UserId = "testUser",
InternalComments = "testInternalComments",
ExternalComments = "testExternalComments"
};
var oversightReviewRepository = new Mock <IOversightReviewRepository>();
oversightReviewRepository.Setup(x => x.Add(It.IsAny <OversightReview>()));
oversightReviewRepository.Setup(x => x.GetByApplicationId(It.IsAny <Guid>())).ReturnsAsync(() => null);
var repository = new Mock <IApplicationRepository>();
repository.Setup(x => x.GetApplication(command.ApplicationId)).ReturnsAsync(() => new Domain.Entities.Apply
{
ApplicationId = command.ApplicationId, Status = ApplicationStatus.Submitted
});
repository.Setup(x => x.Update(It.IsAny <Domain.Entities.Apply>()));
var logger = new Mock <ILogger <RecordOversightOutcomeHandler> >();
var handler = new RecordOversightOutcomeHandler(logger.Object, oversightReviewRepository.Object, repository.Object, Mock.Of <IAuditService>());
var result = await handler.Handle(command, new CancellationToken());
result.Should().BeTrue();
oversightReviewRepository.Verify(
x => x.Add(It.Is <OversightReview>(
r => r.ApplicationId == command.ApplicationId &&
r.ApplicationDeterminedDate.Value.Date == DateTime.UtcNow.Date &&
r.InternalComments == command.InternalComments &&
r.ExternalComments == command.ExternalComments &&
r.Status == command.OversightStatus
)),
Times.Once);
repository.Verify(x => x.Update(It.Is <Domain.Entities.Apply>(apply =>
apply.ApplicationId == command.ApplicationId && apply.ApplicationStatus == applicationStatus)),
Times.Once);
}
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(userName, registrationDetails);
await _registerApiClient.CreateOrganisation(request);
}
if ((outcome == OversightReviewStatus.SuccessfulAlreadyActive ||
outcome == OversightReviewStatus.SuccessfulFitnessForFunding) && registerStatus.OrganisationId != null)
{
var updateOrganisationRequest = new UpdateOrganisationRequest
{
ApplicationDeterminedDate = DateTime.UtcNow.Date,
LegalName = registrationDetails.LegalName,
OrganisationId = registerStatus.OrganisationId.Value,
Username = userName,
CharityNumber = registrationDetails.CharityNumber,
CompanyNumber = registrationDetails.CompanyNumber,
OrganisationTypeId = registrationDetails.OrganisationTypeId,
ProviderTypeId = registrationDetails.ProviderTypeId,
TradingName = registrationDetails.TradingName,
};
_logger.LogInformation($"Updating organisation details for application {applicationId}");
return(await _registerApiClient.UpdateOrganisation(updateOrganisationRequest));
}
return(true);
}
public async Task Application_status_and_register_updated_for_a_successful_already_active_or_fitness_for_funding_oversight_review(OversightReviewStatus status)
{
await _orchestrator.RecordOutcome(_applicationId, false, false, status, UserId, UserName, InternalComments, ExternalComments);
_applicationApiClient.Verify(x => x.RecordOutcome(It.Is <RecordOversightOutcomeCommand>(y => y.ApplicationId == _applicationId)), Times.Once);
_roatpRegisterApiClient.Verify(x => x.UpdateApplicationDeterminedDate(It.Is <UpdateOrganisationApplicationDeterminedDateRequest>(y => y.OrganisationId == _registerStatus.OrganisationId)), Times.Once);
}
