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 Record_oversight_InProgress_Is_Recorded_In_Relevant_Properties()
{
var command = new RecordOversightOutcomeCommand
{
ApplicationId = Guid.NewGuid(),
OversightStatus = OversightReviewStatus.InProgress,
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>(), Mock.Of <IApplicationUpdatedEmailService>(), Mock.Of <IUnitOfWork>());
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.InProgressDate.Value.Date == DateTime.UtcNow.Date &&
r.ApplicationDeterminedDate.Value.Date == DateTime.UtcNow.Date &&
r.InProgressUserId == command.UserId &&
r.InProgressUserName == command.UserName &&
r.InProgressInternalComments == command.InternalComments &&
r.InProgressExternalComments == command.ExternalComments &&
r.InternalComments == null &&
r.ExternalComments == null &&
r.Status == OversightReviewStatus.InProgress
)),
Times.Once);
repository.Verify(x => x.Update(It.Is <Domain.Entities.Apply>(apply =>
apply.ApplicationId == command.ApplicationId && apply.ApplicationStatus == ApplicationStatus.InProgressOutcome)),
Times.Once);
}
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 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()));
}
}
private static CreateRoatpOrganisationRequest BuildCreateOrganisationRequest(RecordOversightOutcomeCommand updateOutcomeCommand, RoatpRegistrationDetails registrationDetails)
{
return(new CreateRoatpOrganisationRequest
{
ApplicationDeterminedDate = DateTime.UtcNow.Date,
CharityNumber = registrationDetails.CharityNumber,
CompanyNumber = registrationDetails.CompanyNumber,
FinancialTrackRecord = true,
LegalName = registrationDetails.LegalName,
NonLevyContract = false,
OrganisationTypeId = registrationDetails.OrganisationTypeId,
ParentCompanyGuarantee = false,
ProviderTypeId = registrationDetails.ProviderTypeId,
SourceIsUKRLP = true,
StatusDate = DateTime.Now,
TradingName = registrationDetails.TradingName,
Ukprn = registrationDetails.UKPRN,
Username = updateOutcomeCommand.UserName
});
}
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 <ActionResult <bool> > RecordOversightOutcome([FromBody] RecordOversightOutcomeCommand command)
{
return(await _mediator.Send(command));
}
public async Task <bool> RecordOutcome(RecordOversightOutcomeCommand command)
{
var statusCode = await Post("Oversight/Outcome", command);
return(await Task.FromResult(statusCode == HttpStatusCode.OK));
}
