public async Task DecisionRequiredByDate_IsDateRetrivedFromDatabase()
{
assessment.Dates.AcknowledgedDate = acknowledgedDateWhenHasValue;
assessment.Dates.DecisionRequiredByDate = decisionRequiredByDateWhenPopulatedInDB;
var decisionRequiredByDate = await decisionRequiredBy.GetDecisionRequiredByDate(assessment);
Assert.Equal(decisionRequiredByDateWhenPopulatedInDB, decisionRequiredByDate);
}
public async Task <NotificationDatesSummary> GetById(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
var assessment = await notificationAssessmentRepository.GetByNotificationId(notificationId);
var notification = await notificationApplicationRepository.GetById(notificationId);
var paymentReceived = await transactionCalculator.PaymentReceivedDate(notificationId) ??
await transactionCalculator.LatestPayment(notificationId);
DateTime?paymentReceivedDate = null;
if (paymentReceived != null)
{
paymentReceivedDate = paymentReceived.Date;
}
return(NotificationDatesSummary.Load(
assessment.Status,
assessment.Dates.NotificationReceivedDate,
notificationId,
paymentReceivedDate,
await transactionCalculator.IsPaymentComplete(notificationId),
assessment.Dates.CommencementDate,
assessment.Dates.NameOfOfficer,
assessment.Dates.CompleteDate,
assessment.Dates.TransmittedDate,
assessment.Dates.AcknowledgedDate,
await decisionRequiredBy.GetDecisionRequiredByDate(notification, assessment),
assessment.Dates.FileClosedDate,
assessment.Dates.ArchiveReference));
}
public async Task <KeyDatesOverrideData> HandleAsync(GetImportKeyDatesOverrideData message)
{
var assessment = await assessmentRepository.GetByNotification(message.NotificationId);
var keyDates = await repository.GetKeyDatesForNotification(message.NotificationId);
keyDates.DecisionRequiredByDate = await decisionRequiredBy.GetDecisionRequiredByDate(assessment);
return(keyDates);
}
public async Task <Unit> HandleAsync(SetImportKeyDatesOverride message)
{
var assessment = await assessmentRepository.GetByNotification(message.Data.NotificationId);
var currentDecisionRequiredByDate = await decisionRequiredBy.GetDecisionRequiredByDate(assessment);
if (currentDecisionRequiredByDate != message.Data.DecisionRequiredByDate)
{
await repository.SetDecisionRequiredByDateForNotification(assessment.Id, message.Data.DecisionRequiredByDate);
}
await repository.SetKeyDatesForNotification(message.Data);
return(Unit.Value);
}
public async Task <KeyDatesData> HandleAsync(GetKeyDates message)
{
var notification = await notificationRepository.Get(message.ImportNotificationId);
var consultation = await consultationRepository.GetByNotificationId(message.ImportNotificationId);
var assessment = await notificationAssessmentRepository.GetByNotification(message.ImportNotificationId);
var interimStatus = await interimStatusRepository.GetByNotificationId(message.ImportNotificationId);
var decisions = await notificationAssessmentDecisionRepository.GetByImportNotificationId(message.ImportNotificationId);
var paymentReceived = await transactionCalculator.PaymentReceivedDate(message.ImportNotificationId) ??
await transactionCalculator.LatestPayment(message.ImportNotificationId);
DateTime?paymentReceivedDate = null;
if (paymentReceived != null)
{
paymentReceivedDate = paymentReceived.Date;
}
return(new KeyDatesData
{
NotificationReceived = assessment.Dates.NotificationReceivedDate,
PaymentReceived = paymentReceivedDate,
IsPaymentComplete = assessment.Dates.PaymentReceivedDate.HasValue &&
await transactionCalculator.PaymentIsNowFullyReceived(message.ImportNotificationId, 0),
NameOfOfficer = assessment.Dates.NameOfOfficer,
AssessmentStarted = assessment.Dates.AssessmentStartedDate,
NotificationCompletedDate = assessment.Dates.NotificationCompletedDate,
AcknowlegedDate = assessment.Dates.AcknowledgedDate,
DecisionRequiredByDate = await decisionRequiredBy.GetDecisionRequiredByDate(assessment),
IsInterim = interimStatus.IsInterim,
FileClosedDate = assessment.Dates.FileClosedDate,
ArchiveReference = assessment.Dates.ArchiveReference,
DecisionHistory = decisions ?? new List <NotificationAssessmentDecision>(),
CompententAuthority = notification.CompetentAuthority,
IsLocalAreaSet = consultation != null && consultation.LocalAreaId.HasValue,
Status = assessment.Status
});
}
private async Task <NotificationAttentionSummaryTableData> GetTableDataFromSummary(NotificationAttentionSummary summary)
{
var assessment = await notificationAssessmentRepository.GetByNotificationId(summary.NotificationId);
var notification = await notificationApplicationRepository.GetById(summary.NotificationId);
var decisionRequiredBy = await decisionRequiredByCalculator.GetDecisionRequiredByDate(notification, assessment);
var daysRemaining = daysRemainingCalculator.Calculate(decisionRequiredBy.Value);
return(new NotificationAttentionSummaryTableData
{
NotificationId = summary.NotificationId,
NotificationNumber = summary.NotificationNumber,
Officer = summary.Officer,
AcknowledgedDate = summary.AcknowledgedDate,
DecisionRequiredDate = decisionRequiredBy.Value,
DaysRemaining = daysRemaining
});
}
