public async Task <bool> Handle(UpdateGatewayPageAnswerRequest request, CancellationToken cancellationToken)
{
_auditService.StartTracking(UserAction.UpdateGatewayPageOutcome, request.UserId, request.UserName);
var application = await _applyRepository.GetApplication(request.ApplicationId);
var answer = await _gatewayRepository.GetGatewayPageAnswer(request.ApplicationId, request.PageId);
var isNew = answer == null;
if (isNew)
{
answer = CreateNewGatewayPageAnswer(request.ApplicationId, request.PageId);
_auditService.AuditInsert(answer);
}
else
{
_auditService.AuditUpdate(answer);
}
if (answer != null)
{
answer.Status = request.Status;
answer.Comments = request.Comments;
answer.UpdatedAt = DateTime.UtcNow;
answer.UpdatedBy = request.UserName;
answer.ClarificationAnswer = request.ClarificationAnswer;
if (string.IsNullOrEmpty(answer.ClarificationAnswer))
{
answer.ClarificationComments = null;
answer.ClarificationBy = null;
answer.ClarificationDate = null;
}
}
bool updatedSuccessfully;
if (isNew)
{
updatedSuccessfully = await _gatewayRepository.InsertGatewayPageAnswer(answer, request.UserId, request.UserName);
}
else
{
updatedSuccessfully = await _gatewayRepository.UpdateGatewayPageAnswer(answer, request.UserId, request.UserName);
}
if (application.GatewayUserId != request.UserId || application.GatewayUserName != request.UserName)
{
_auditService.AuditUpdate(application);
application.GatewayUserId = request.UserId;
application.GatewayUserName = request.UserName;
application.UpdatedBy = request.UserName;
application.UpdatedAt = DateTime.UtcNow;
await _applyRepository.UpdateApplication(application);
}
_auditService.Save();
return(updatedSuccessfully);
}
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 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);
}
public async Task <Unit> Handle(CreateAppealCommand request, CancellationToken cancellationToken)
{
var oversightReview = await GetOversightReview(request.OversightReviewId, request.ApplicationId);
await VerifyAppealDoesNotExist(request.OversightReviewId);
_auditService.StartTracking(UserAction.CreateAppeal, request.UserId, request.UserName);
var appeal = new Appeal
{
OversightReviewId = request.OversightReviewId,
Message = request.Message,
UserId = request.UserId,
UserName = request.UserName
};
_appealRepository.Add(appeal);
_auditService.AuditInsert(appeal);
var uploads = await _appealUploadRepository.GetByApplicationId(oversightReview.ApplicationId);
foreach (var upload in uploads)
{
_auditService.AuditUpdate(upload);
upload.AppealId = appeal.Id;
_appealUploadRepository.Update(upload);
}
_auditService.Save();
return(Unit.Value);
}
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 async Task <Unit> Handle(MakeAppealCommand request, CancellationToken cancellationToken)
{
var oversightReview = await _oversightReviewRepository.GetByApplicationId(request.ApplicationId);
VerifyOversightReviewIsUnsuccessfulOrRemoved(oversightReview);
var currentAppeal = await _appealRepository.GetByApplicationId(request.ApplicationId);
VerifyAppealNotSubmitted(currentAppeal);
_auditService.StartTracking(UserAction.MakeAppeal, request.UserId, request.UserName);
if (currentAppeal is null)
{
currentAppeal = new Appeal
{
ApplicationId = request.ApplicationId,
Status = AppealStatus.Submitted,
AppealSubmittedDate = DateTime.UtcNow,
HowFailedOnPolicyOrProcesses = request.HowFailedOnPolicyOrProcesses,
HowFailedOnEvidenceSubmitted = request.HowFailedOnEvidenceSubmitted,
UserId = request.UserId,
UserName = request.UserName,
};
_auditService.AuditInsert(currentAppeal);
_appealRepository.Add(currentAppeal);
}
else
{
_auditService.AuditUpdate(currentAppeal);
currentAppeal.Status = AppealStatus.Submitted;
currentAppeal.AppealSubmittedDate = DateTime.UtcNow;
currentAppeal.HowFailedOnPolicyOrProcesses = request.HowFailedOnPolicyOrProcesses;
currentAppeal.HowFailedOnEvidenceSubmitted = request.HowFailedOnEvidenceSubmitted;
currentAppeal.UserId = request.UserId;
currentAppeal.UserName = request.UserName;
currentAppeal.UpdatedOn = DateTime.UtcNow;
_appealRepository.Update(currentAppeal);
}
_auditService.Save();
return(Unit.Value);
}
public async Task <Unit> Handle(UploadAppealFileCommand request, CancellationToken cancellationToken)
{
_auditService.StartTracking(UserAction.UploadAppealFile, request.UserId, request.UserName);
var appealFile = await _appealFileRepository.Get(request.ApplicationId, request.AppealFile.FileName);
if (appealFile is null)
{
appealFile = new AppealFile
{
ApplicationId = request.ApplicationId,
ContentType = request.AppealFile.ContentType,
FileName = request.AppealFile.FileName,
Size = request.AppealFile.Data.Length,
UserId = request.UserId,
UserName = request.UserName
};
_auditService.AuditInsert(appealFile);
_appealFileRepository.Add(appealFile);
}
else
{
_auditService.AuditUpdate(appealFile);
appealFile.ContentType = request.AppealFile.ContentType;
appealFile.Size = request.AppealFile.Data.Length;
appealFile.UserId = request.UserId;
appealFile.UserName = request.UserName;
appealFile.CreatedOn = DateTime.UtcNow;
_appealFileRepository.Update(appealFile);
}
_auditService.Save();
return(await Task.FromResult(Unit.Value));
}
public async Task <Unit> Handle(UploadAppealFileCommand request, CancellationToken cancellationToken)
{
_auditService.StartTracking(UserAction.UploadAppealFile, request.UserId, request.UserName);
var fileStorageReference = await _appealsFileStorage.Add(request.ApplicationId, request.File, cancellationToken);
var appealUpload = new AppealUpload
{
ApplicationId = request.ApplicationId,
FileStorageReference = fileStorageReference,
ContentType = request.File.ContentType,
Filename = request.File.Filename,
Size = request.File.Data.Length,
UserId = request.UserId,
UserName = request.UserName
};
_appealUploadRepository.Add(appealUpload);
_auditService.AuditInsert(appealUpload);
_auditService.Save();
return(Unit.Value);
}
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);
}
private async Task <(Appeal, bool)> GetExistingAppeal(Guid applicationId)
{
var isNew = false;
var appeal = await _appealRepository.GetByApplicationId(applicationId);
if (appeal == null)
{
isNew = true;
appeal = new Appeal {
ApplicationId = applicationId
};
_auditService.AuditInsert(appeal);
}
else
{
if (appeal.Status != AppealStatus.InProgress && appeal.Status != AppealStatus.Submitted)
{
throw new InvalidOperationException($"Unable to modify appeal review for application {applicationId} with a status of {appeal.Status}");
}
_auditService.AuditUpdate(appeal);
}
return(appeal, isNew);
}
