public async Task <Unit> Handle(AssignVacancyReviewCommand message, CancellationToken cancellationToken)
{
VacancyReview review;
if (message.ReviewId.HasValue)
{
_logger.LogInformation("Starting assignment of review for user {userId} for review {reviewId}", message.User.UserId, message.ReviewId);
review = await GetVacancyReviewAsync(message.ReviewId.Value);
}
else
{
_logger.LogInformation("Starting assignment of next review for user {userId}.", message.User.UserId);
review = await GetNextVacancyReviewForUser(message.User.UserId);
}
if (review == null)
{
return(Unit.Value);
}
review.Status = ReviewStatus.UnderReview;
review.ReviewedByUser = message.User;
review.ReviewedDate = _time.Now;
await _vacancyReviewRepository.UpdateAsync(review);
return(Unit.Value);
}
public async Task Handle(ApproveVacancyReviewCommand message, CancellationToken cancellationToken)
{
_logger.LogInformation("Approving review {reviewId}.", message.ReviewId);
var review = await _vacancyReviewRepository.GetAsync(message.ReviewId);
if (!review.CanApprove)
{
_logger.LogWarning($"Unable to approve review {{reviewId}} due to review having a status of {review.Status}.", message.ReviewId);
return;
}
review.ManualOutcome = ManualQaOutcome.Approved;
review.Status = ReviewStatus.Closed;
review.ClosedDate = _timeProvider.Now;
review.ManualQaComment = message.ManualQaComment;
review.ManualQaFieldIndicators = message.ManualQaFieldIndicators;
foreach (var automatedQaOutcomeIndicator in review.AutomatedQaOutcomeIndicators)
{
automatedQaOutcomeIndicator.IsReferred = message.SelectedAutomatedQaRuleOutcomeIds
.Contains(automatedQaOutcomeIndicator.RuleOutcomeId);
}
Validate(review);
await _vacancyReviewRepository.UpdateAsync(review);
await _messaging.PublishEvent(new VacancyReviewApprovedEvent
{
ReviewId = message.ReviewId,
VacancyReference = review.VacancyReference
});
}
private Task ClosePendingReview(VacancyReview review)
{
_logger.LogInformation($"Closing pending review {review.Id} as the provider is blocked");
review.ManualOutcome = ManualQaOutcome.Blocked;
review.Status = ReviewStatus.Closed;
review.ClosedDate = _timeProvider.Now;
return _vacancyReviewRepository.UpdateAsync(review);
}
public async Task <Unit> Handle(ApproveVacancyReviewCommand message, CancellationToken cancellationToken)
{
_logger.LogInformation("Approving review {reviewId}.", message.ReviewId);
var review = await _vacancyReviewRepository.GetAsync(message.ReviewId);
var vacancy = await _vacancyRepository.GetVacancyAsync(review.VacancyReference);
if (!review.CanApprove)
{
_logger.LogWarning($"Unable to approve review {{reviewId}} due to review having a status of {review.Status}.", message.ReviewId);
return(Unit.Value);
}
review.ManualOutcome = ManualQaOutcome.Approved;
review.Status = ReviewStatus.Closed;
review.ClosedDate = _timeProvider.Now;
review.ManualQaComment = message.ManualQaComment;
review.ManualQaFieldIndicators = message.ManualQaFieldIndicators;
foreach (var automatedQaOutcomeIndicator in review.AutomatedQaOutcomeIndicators)
{
automatedQaOutcomeIndicator.IsReferred = message.SelectedAutomatedQaRuleOutcomeIds
.Contains(automatedQaOutcomeIndicator.RuleOutcomeId);
}
Validate(review);
await _vacancyReviewRepository.UpdateAsync(review);
var closureReason = await TryGetReasonToCloseVacancy(review, vacancy);
if (closureReason != null)
{
await CloseVacancyAsync(vacancy, closureReason.Value);
await SendNotificationToEmployerAsync(vacancy.TrainingProvider.Ukprn.GetValueOrDefault(), vacancy.EmployerAccountId);
await _dashboardService.ReBuildDashboardAsync(vacancy.EmployerAccountId);
return(Unit.Value);
}
await PublishVacancyReviewApprovedEventAsync(message, review);
return(Unit.Value);
}
public async Task Handle(UnassignVacancyReviewCommand message, CancellationToken cancellationToken)
{
_logger.LogInformation("Attempting to unassign review {reviewId}.", message.ReviewId);
var review = await _repository.GetAsync(message.ReviewId);
if (!review.CanUnassign)
{
_logger.LogWarning($"Unable to unassign {review.ReviewedByUser.Name} from review {message.ReviewId}, it may already be unassigned.");
return;
}
review.Status = ReviewStatus.PendingReview;
review.ReviewedDate = null;
review.ReviewedByUser = null;
await _repository.UpdateAsync(review);
}
public async Task PerformRulesCheckAsync(Guid reviewId)
{
var review = await _vacancyReviewRepository.GetAsync(reviewId);
var outcome = await _vacancyRuleSet.EvaluateAsync(review.VacancySnapshot);
review.AutomatedQaOutcome = outcome;
review.Status = ReviewStatus.PendingReview;
review.AutomatedQaOutcomeIndicators =
outcome
.RuleOutcomes
.SelectMany(o => o.Details)
.Where(s => s.Score > 0) //Eventually this should be check against threshold for that rule
.Select(r => new RuleOutcomeIndicator {
RuleOutcomeId = r.Id, IsReferred = true
})
.ToList();
await _vacancyReviewRepository.UpdateAsync(review);
}
public async Task CloseVacancyReview(long vacancyReference, TransferReason transferReason)
{
var review = await _vacancyReviewQuery.GetLatestReviewByReferenceAsync(vacancyReference);
if (review.IsPending)
{
review.ManualOutcome = transferReason == TransferReason.BlockedByQa
? ManualQaOutcome.Blocked
: ManualQaOutcome.Transferred;
review.Status = ReviewStatus.Closed;
review.ClosedDate = _timeProvider.Now;
await _vacancyReviewRepository.UpdateAsync(review);
}
else if (review.Status == ReviewStatus.UnderReview)
{
_logger.LogWarning($"Latest review for vacancy {review.VacancyReference} that has been transferred is currently being reviewed.");
}
}
public async Task Handle(ApproveReferredVacancyReviewCommand message, CancellationToken cancellationToken)
{
_logger.LogInformation("Approving referred review {reviewId}", message.ReviewId);
var review = await _vacancyReviewRepository.GetAsync(message.ReviewId);
if (!review.CanApprove)
{
_logger.LogWarning($"Unable to approve review {{reviewId}} for vacancy {{vacancyReference}} due to review having a status of {review.Status}.", message.ReviewId, review.VacancyReference);
return;
}
var vacancy = await _vacancyRepository.GetVacancyAsync(review.VacancyReference);
if (!vacancy.CanApprove)
{
_logger.LogWarning($"Unable to approve review {{reviewId}} for vacancy {{vacancyReference}} due to vacancy having a status of {vacancy.Status}.", message.ReviewId, vacancy.VacancyReference);
return;
}
review.ManualOutcome = ManualQaOutcome.Approved;
review.Status = ReviewStatus.Closed;
vacancy.ShortDescription = message.ShortDescription;
vacancy.Description = message.VacancyDescription;
vacancy.TrainingDescription = message.TrainingDescription;
vacancy.OutcomeDescription = message.OutcomeDescription;
vacancy.ThingsToConsider = message.ThingsToConsider;
vacancy.EmployerDescription = message.EmployerDescription;
await _vacancyRepository.UpdateAsync(vacancy);
await _vacancyReviewRepository.UpdateAsync(review);
await _messaging.PublishEvent(new VacancyReviewApprovedEvent
{
ReviewId = message.ReviewId,
VacancyReference = vacancy.VacancyReference.Value
});
}