public async Task <bool> RecordAppeal(Guid applicationId, string appealStatus, string userId, string userName, string internalComments,
string externalComments)
{
_logger.LogInformation($"Recording an appeal outcome of {appealStatus} for application {applicationId}");
var registrationDetails = await _applicationApiClient.GetRegistrationDetails(applicationId);
var registerStatus = await _registerApiClient.GetOrganisationRegisterStatus(new GetOrganisationRegisterStatusRequest { UKPRN = registrationDetails.UKPRN });
ValidateAppealStatusAgainstExistingStatus(appealStatus, registerStatus, registrationDetails.UKPRN);
var updateAppealCommand = new RecordAppealOutcomeCommand
{
ApplicationId = applicationId,
AppealStatus = appealStatus,
UserId = userId,
UserName = userName,
InternalComments = internalComments,
ExternalComments = externalComments
};
var updateOutcomeSuccess = await _applicationApiClient.RecordAppeal(updateAppealCommand);
if (!updateOutcomeSuccess)
{
return(false);
}
return(await RecordInRoatp(applicationId, appealStatus, userId, userName, registerStatus, registrationDetails));
}
public async Task Record_appeal_InProgress_Is_Recorded_In_Relevant_Properties()
{
var command = new RecordAppealOutcomeCommand
{
ApplicationId = Guid.NewGuid(),
AppealStatus = AppealStatus.InProgress,
UserName = "******",
UserId = "testUser",
InternalComments = "testInternalComments",
ExternalComments = "testExternalComments"
};
var appealRepository = new Mock <IAppealRepository>();
appealRepository.Setup(x => x.Add(It.IsAny <Appeal>()));
appealRepository.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 <RecordAppealOutcomeHandler> >();
var handler = new RecordAppealOutcomeHandler(logger.Object, appealRepository.Object, repository.Object, Mock.Of <IAuditService>(), Mock.Of <IUnitOfWork>(), Mock.Of <IApplicationUpdatedEmailService>());
var result = await handler.Handle(command, new CancellationToken());
result.Should().BeTrue();
appealRepository.Verify(
x => x.Add(It.Is <Appeal>(
r => r.ApplicationId == command.ApplicationId &&
r.InProgressDate.Value.Date == DateTime.UtcNow.Date &&
r.AppealDeterminedDate == null &&
r.InProgressUserId == command.UserId &&
r.InProgressUserName == command.UserName &&
r.InProgressInternalComments == command.InternalComments &&
r.InProgressExternalComments == command.ExternalComments &&
r.InternalComments == null &&
r.ExternalComments == null &&
r.Status == AppealStatus.InProgress
)),
Times.Once);
repository.Verify(x => x.Update(It.Is <Domain.Entities.Apply>(apply =>
apply.ApplicationId == command.ApplicationId && apply.ApplicationStatus == ApplicationStatus.InProgressAppeal)),
Times.Once);
}
public async Task Record_appeal_outcome_updates_appeal_status_and_applies_correct_application_status(string appealStatus, string applicationStatus, string gatewayReviewStatus, int noOfCallsToApply)
{
var command = new RecordAppealOutcomeCommand
{
ApplicationId = Guid.NewGuid(),
AppealStatus = appealStatus,
UserName = "******",
UserId = "testUser",
InternalComments = "testInternalComments",
ExternalComments = "testExternalComments"
};
var appealRepository = new Mock <IAppealRepository>();
appealRepository.Setup(x => x.Add(It.IsAny <Appeal>()));
appealRepository.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, GatewayReviewStatus = gatewayReviewStatus
});
repository.Setup(x => x.Update(It.IsAny <Domain.Entities.Apply>()));
var logger = new Mock <ILogger <RecordAppealOutcomeHandler> >();
var handler = new RecordAppealOutcomeHandler(logger.Object, appealRepository.Object, repository.Object, Mock.Of <IAuditService>(), Mock.Of <IUnitOfWork>(), Mock.Of <IApplicationUpdatedEmailService>());
var result = await handler.Handle(command, new CancellationToken());
result.Should().BeTrue();
appealRepository.Verify(
x => x.Add(It.Is <Appeal>(
r => r.ApplicationId == command.ApplicationId &&
r.AppealDeterminedDate.Value.Date == DateTime.UtcNow.Date &&
r.InternalComments == command.InternalComments &&
r.ExternalComments == command.ExternalComments &&
r.Status == command.AppealStatus
)),
Times.Once);
repository.Verify(x => x.Update(It.Is <Domain.Entities.Apply>(apply =>
apply.ApplicationId == command.ApplicationId && apply.ApplicationStatus == applicationStatus)),
Times.Exactly(noOfCallsToApply));
}
public async Task Record_appeal_outcome_updates_appeal_status(string appealStatus)
{
var command = new RecordAppealOutcomeCommand
{
AppealStatus = appealStatus,
ApplicationId = Guid.NewGuid(),
UserId = "User Id",
UserName = "******"
};
_mediator.Setup(x => x.Send(command, It.IsAny <CancellationToken>())).ReturnsAsync(true);
var result = await _controller.RecordAppealOutcome(command);
result.Should().NotBeNull();
result.Value.Should().BeTrue();
}
public async Task Handle_User_Is_Notified_Of_Update_To_Applicant()
{
var request = new RecordAppealOutcomeCommand
{
ApplicationId = _applicationId,
UserId = "test user id",
UserName = "******",
AppealStatus = AppealStatus.Successful,
ExternalComments = "External Commnets",
InternalComments = "Internal Comments",
};
_handler = new RecordAppealOutcomeHandler(_logger.Object, _appealRepository.Object, _applicationRepository.Object, _auditService.Object, _unitOfWork.Object, _applicationUpdatedEmailService.Object);
await _handler.Handle(request, CancellationToken.None);
_applicationUpdatedEmailService.Verify(x => x.SendEmail(request.ApplicationId), Times.Once);
}
public void Record_appeal_Throws_Exception_If_Already_Recorded_Unless_InProgress(string originalStatus, bool expectThrows)
{
var applicationId = Guid.NewGuid();
var command = new RecordAppealOutcomeCommand
{
ApplicationId = applicationId,
AppealStatus = AppealStatus.Successful,
UserName = "******",
UserId = "testUser",
InternalComments = "testInternalComments",
ExternalComments = "testExternalComments"
};
var existingAppeal = new Appeal
{
Status = originalStatus
};
var appealRepository = new Mock <IAppealRepository>();
appealRepository.Setup(x => x.Update(It.IsAny <Appeal>()));
appealRepository.Setup(x => x.GetByApplicationId(It.IsAny <Guid>())).ReturnsAsync(() => existingAppeal);
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 <RecordAppealOutcomeHandler> >();
var handler = new RecordAppealOutcomeHandler(logger.Object, appealRepository.Object, repository.Object, Mock.Of <IAuditService>(), Mock.Of <IUnitOfWork>(), Mock.Of <IApplicationUpdatedEmailService>());
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 <ActionResult <bool> > RecordAppealOutcome([FromBody] RecordAppealOutcomeCommand command)
{
return(await _mediator.Send(command));
}
public async Task <bool> RecordAppeal(RecordAppealOutcomeCommand command)
{
var statusCode = await Post("Oversight/Appeal", command);
return(await Task.FromResult(statusCode == HttpStatusCode.OK));
}
