public async Task <bool> Handle(WithdrawApplicationCommand request, CancellationToken cancellationToken)
{
_logger.LogInformation($"Performing Withdraw Application action for ApplicationId: {request.ApplicationId}");
var oversightReview = new OversightReview
{
ApplicationId = request.ApplicationId,
Status = OversightReviewStatus.Withdrawn,
InternalComments = request.Comments,
UserId = request.UserId,
UserName = request.UserName
};
var result = await _gatewayRepository.WithdrawApplication(request.ApplicationId, request.Comments, request.UserId, request.UserName);
try
{
if (result)
{
await _applicationUpdatedEmailService.SendEmail(request.ApplicationId);
}
}
catch (Exception ex)
{
_logger.LogError(ex, $"Unable to send withdraw confirmation email for application: {request.ApplicationId}");
}
_auditService.StartTracking(UserAction.WithdrawApplication, request.UserId, request.UserName);
_auditService.AuditInsert(oversightReview);
_oversightReviewRepository.Add(oversightReview);
_auditService.Save();
return(result);
}
private void ApplyChanges(OversightReview oversightReview, RecordOversightOutcomeCommand request, bool isNew)
{
oversightReview.GatewayApproved = request.ApproveGateway;
oversightReview.ModerationApproved = request.ApproveModeration;
oversightReview.Status = request.OversightStatus;
if (!isNew)
{
oversightReview.UpdatedOn = DateTime.UtcNow;
}
if (request.OversightStatus == OversightReviewStatus.InProgress)
{
oversightReview.InProgressDate = DateTime.UtcNow;
oversightReview.InProgressInternalComments = request.InternalComments;
oversightReview.InProgressExternalComments = request.ExternalComments;
oversightReview.InProgressUserId = request.UserId;
oversightReview.InProgressUserName = request.UserName;
}
else
{
oversightReview.InternalComments = request.InternalComments;
oversightReview.ExternalComments = request.ExternalComments;
oversightReview.UserId = request.UserId;
oversightReview.UserName = request.UserName;
}
}
public void SetUp()
{
_oversightReview = new OversightReview
{
ApplicationId = _applicationId,
Status = OversightReviewStatus.Unsuccessful
};
_oversightReviewRepository = new Mock <IOversightReviewRepository>();
_oversightReviewRepository.Setup(x => x.GetByApplicationId(_applicationId)).ReturnsAsync(() => _oversightReview);
_command = new MakeAppealCommand
{
ApplicationId = _applicationId,
HowFailedOnPolicyOrProcesses = "howFailedOnPolicyOrProcesses",
HowFailedOnEvidenceSubmitted = "howFailedOnEvidenceSubmitted",
UserId = "userId",
UserName = "******"
};
_appealRepository = new Mock <IAppealRepository>();
_appealRepository.Setup(x => x.Add(It.IsAny <Appeal>()));
_auditService = new Mock <IAuditService>();
_auditService.Setup(x => x.StartTracking(UserAction.UploadAppealFile, _command.UserId, _command.UserName));
_auditService.Setup(x => x.AuditInsert(It.IsAny <AppealFile>()));
_handler = new MakeAppealCommandHandler(_oversightReviewRepository.Object, _appealRepository.Object, _auditService.Object);
}
private void SaveChanges(OversightReview oversightReview, Domain.Entities.Apply application, bool isNew)
{
if (isNew)
{
_oversightReviewRepository.Add(oversightReview);
}
else
{
_oversightReviewRepository.Update(oversightReview);
}
switch (oversightReview.Status)
{
case OversightReviewStatus.InProgress:
application.ApplicationStatus = ApplicationStatus.InProgressOutcome;
break;
case OversightReviewStatus.Successful:
case OversightReviewStatus.SuccessfulAlreadyActive:
case OversightReviewStatus.SuccessfulFitnessForFunding:
application.ApplicationStatus = ApplicationStatus.Successful;
break;
case OversightReviewStatus.Unsuccessful:
application.ApplicationStatus = application.GatewayReviewStatus == GatewayReviewStatus.Rejected
? ApplicationStatus.Rejected :
ApplicationStatus.Unsuccessful;
break;
}
_applyRepository.Update(application);
}
public async Task <Unit> Handle(RecordOversightGatewayRemovedOutcomeCommand request, CancellationToken cancellationToken)
{
_logger.LogInformation($"Recording Oversight review status of Unsuccessful for gateway removed application Id {request.ApplicationId}");
var application = await _applyRepository.GetApplication(request.ApplicationId);
if (application == null)
{
throw new InvalidOperationException($"Application {request.ApplicationId} not found");
}
var oversightReview = new OversightReview
{
ApplicationId = request.ApplicationId,
Status = OversightReviewStatus.Removed,
UserId = request.UserId,
UserName = request.UserName,
};
_auditService.StartTracking(UserAction.RecordOversightGatewayRemovedOutcome, request.UserId, request.UserName);
_auditService.AuditInsert(oversightReview);
_oversightReviewRepository.Add(oversightReview);
_auditService.Save();
await _unitOfWork.Commit();
await _applicationUpdatedEmailService.SendEmail(request.ApplicationId);
return(Unit.Value);
}
public void Setup()
{
var autoFixture = new Fixture();
_query = autoFixture.Create <GetOversightReviewQuery>();
_queryResult = autoFixture.Create <OversightReview>();
_appealsQueries = new Mock <IOversightReviewQueries>();
_appealsQueries.Setup(x => x.GetOversightReview(_query.ApplicationId)).ReturnsAsync(() => _queryResult);
_handler = new GetOversightReviewQueryHandler(_appealsQueries.Object);
}
public void SetUp()
{
_fixture = new Fixture();
_appealId = Guid.NewGuid();
_oversightReview = new OversightReview
{
Id = _oversightReviewId,
ApplicationId = _applicationId,
Status = OversightReviewStatus.Unsuccessful
};
_appealUploads = new List <AppealUpload>
{
new AppealUpload
{
Id = Guid.NewGuid(),
ApplicationId = _applicationId
},
new AppealUpload
{
Id = Guid.NewGuid(),
ApplicationId = _applicationId
}
};
_command = new CreateAppealCommand
{
ApplicationId = _applicationId,
OversightReviewId = _oversightReviewId,
Message = _fixture.Create <string>(),
UserId = _fixture.Create <string>(),
UserName = _fixture.Create <string>()
};
_oversightReviewRepository = new Mock <IOversightReviewRepository>();
_oversightReviewRepository.Setup(x => x.GetById(_oversightReviewId))
.ReturnsAsync(() => _oversightReview);
_appealRepository = new Mock <IAppealRepository>();
_appealRepository.Setup(x => x.Add(It.IsAny <Appeal>())).Callback <Appeal>(appeal => _appealId = appeal.Id);
_appealUploadRepository = new Mock <IAppealUploadRepository>();
_appealUploadRepository.Setup(x => x.GetByApplicationId(_applicationId)).ReturnsAsync(_appealUploads);
_auditService = new Mock <IAuditService>();
_auditService.Setup(x => x.StartTracking(UserAction.UploadAppealFile, _command.UserId, _command.UserName));
_auditService.Setup(x => x.AuditInsert(It.IsAny <AppealUpload>()));
_handler = new CreateAppealCommandHandler(_oversightReviewRepository.Object, _appealRepository.Object, _appealUploadRepository.Object, _auditService.Object);
}
private void VerifyOversightReviewIsUnsuccessfulOrRemoved(OversightReview oversightReview)
{
var allowedStatuses = new[] { OversightReviewStatus.Unsuccessful, OversightReviewStatus.Removed };
if (oversightReview is null)
{
throw new InvalidOperationException($"OversightReview for Application {oversightReview.ApplicationId} not found");
}
else if (!allowedStatuses.Contains(oversightReview.Status))
{
throw new InvalidOperationException($"OversightReview for Application {oversightReview.ApplicationId} has status {oversightReview.Status} and cannot be appealed");
}
}
public async Task <bool> Handle(UpdateGatewayReviewStatusAndCommentCommand request, CancellationToken cancellationToken)
{
_auditService.StartTracking(UserAction.UpdateGatewayReviewStatus, request.UserId, request.UserName);
var application = await _applyRepository.GetApplication(request.ApplicationId);
if (application?.ApplyData == null)
{
throw new InvalidOperationException($"Application {request.ApplicationId} not found");
}
else if (application.ApplyData.GatewayReviewDetails == null)
{
application.ApplyData.GatewayReviewDetails = new ApplyGatewayDetails();
}
_auditService.AuditUpdate(application);
application.ApplicationStatus = request.GatewayReviewStatus == GatewayReviewStatus.Rejected ? ApplicationStatus.Rejected : ApplicationStatus.GatewayAssessed;
application.GatewayReviewStatus = request.GatewayReviewStatus;
application.ApplyData.GatewayReviewDetails.OutcomeDateTime = DateTime.UtcNow;
application.ApplyData.GatewayReviewDetails.Comments = request.GatewayReviewComment;
application.ApplyData.GatewayReviewDetails.ExternalComments = request.GatewayReviewExternalComment;
application.ApplyData.GatewayReviewDetails.SubcontractingLimit = request.SubcontractingLimit;
var updatedSuccessfully = await _gatewayRepository.UpdateGatewayReviewStatusAndComment(application.ApplicationId, application.ApplyData, application.GatewayReviewStatus, request.UserId, request.UserName);
if (updatedSuccessfully && request.GatewayReviewStatus == GatewayReviewStatus.Rejected)
{
var oversightReview = new OversightReview
{
ApplicationId = request.ApplicationId,
Status = OversightReviewStatus.Rejected,
UserId = request.UserId,
UserName = request.UserName,
InternalComments = request.GatewayReviewComment,
ExternalComments = request.GatewayReviewExternalComment
};
_auditService.AuditInsert(oversightReview);
_oversightReviewRepository.Add(oversightReview);
await _applicationUpdatedEmailService.SendEmail(request.ApplicationId);
}
_auditService.Save();
await _unitOfWork.Commit();
return(updatedSuccessfully);
}
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 PersistAdd(OversightReview entity)
{
var transaction = _unitOfWork.GetTransaction();
await transaction.Connection.ExecuteAsync(
@"INSERT INTO [OversightReview]
([Id],
[ApplicationId],
[GatewayApproved],
[ModerationApproved],
[Status],
[ApplicationDeterminedDate],
[InternalComments],
[ExternalComments],
[UserId],
[UserName],
[InProgressDate],
[InProgressUserId],
[InProgressUserName],
[InProgressInternalComments],
[InProgressExternalComments],
[CreatedOn])
VALUES (
@Id,
@ApplicationId,
@GatewayApproved,
@ModerationApproved,
@Status,
@ApplicationDeterminedDate,
@InternalComments,
@ExternalComments,
@UserId,
@UserName,
@InProgressDate,
@InProgressUserId,
@InProgressUserName,
@InProgressInternalComments,
@InProgressExternalComments,
@CreatedOn)",
entity, transaction);
}
private void SaveChanges(OversightReview oversightReview, Domain.Entities.Apply application, bool isNew)
{
if (isNew)
{
_oversightReviewRepository.Add(oversightReview);
}
else
{
_oversightReviewRepository.Update(oversightReview);
}
if (oversightReview.Status == OversightReviewStatus.InProgress)
{
return;
}
application.ApplicationStatus = oversightReview.Status == OversightReviewStatus.Unsuccessful
? ApplicationStatus.Rejected
: ApplicationStatus.Approved;
_applyRepository.Update(application);
}
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 PersistUpdate(OversightReview entity)
{
var transaction = _unitOfWork.GetTransaction();
await transaction.Connection.ExecuteAsync(
@"UPDATE [OversightReview]
SET [GatewayApproved] = @GatewayApproved,
[ModerationApproved] = @ModerationApproved,
[Status] = @Status,
[ApplicationDeterminedDate] = @ApplicationDeterminedDate,
[InternalComments] = @InternalComments,
[ExternalComments] = @ExternalComments,
[UserId] = @UserId,
[UserName] = @UserName,
[InProgressDate] = @InProgressDate,
[InProgressUserId] = @InProgressUserId,
[InProgressUserName] = @InProgressUserName,
[InProgressInternalComments] = @InProgressInternalComments,
[InProgressExternalComments] = @InProgressExternalComments,
[UpdatedOn] = @updatedOn
WHERE [Id] = @id",
entity, transaction);
}
private async Task <(OversightReview, bool)> GetExistingOrNewOversightReview(Guid applicationId)
{
var isNew = false;
var oversightReview = await _oversightReviewRepository.GetByApplicationId(applicationId);
if (oversightReview == null)
{
isNew = true;
oversightReview = new OversightReview {
ApplicationId = applicationId
};
_auditService.AuditInsert(oversightReview);
}
else
{
if (oversightReview.Status != OversightReviewStatus.InProgress)
{
throw new InvalidOperationException($"Unable to modify oversight review for application {applicationId} with a status of {oversightReview.Status}");
}
_auditService.AuditUpdate(oversightReview);
}
return(oversightReview, isNew);
}
public void Add(OversightReview entity)
{
_unitOfWork.Register(() => PersistAdd(entity));
}
public void Update(OversightReview entity)
{
_unitOfWork.Register(() => PersistUpdate(entity));
}
