public async Task <IActionResult> Index(int?collectionYear, int?period, CancellationToken cancellationToken)
{
var currentYearPeriod = await _periodService.ReturnPeriod(CollectionTypes.ILR, cancellationToken);
currentYearPeriod.Year = currentYearPeriod.Year ?? 0;
PeriodEndViewModel model;
if (collectionYear != null && period != null)
{
model = await ShowPath(collectionYear.Value, period.Value);
model.Year = collectionYear.Value;
model.Period = period.Value;
}
else
{
model = await ShowPath(currentYearPeriod.Year.Value, currentYearPeriod.Period);
model.Year = currentYearPeriod.Year.Value;
model.Period = currentYearPeriod.Period;
}
var isCurrentPeriodSelected = currentYearPeriod.Year == model.Year && currentYearPeriod.Period == model.Period;
var isPreviousPeriod = currentYearPeriod.Year == model.Year && currentYearPeriod.Period == model.Period + 1;
model.IsPreviousPeriod = isPreviousPeriod;
model.IsCurrentPeriod = isCurrentPeriodSelected;
return(View(model));
}
private async Task SetButtonStates(CancellationToken cancellationToken)
{
var period = await _periodService.ReturnPeriod(CollectionType, cancellationToken);
var periodClosed = period.PeriodClosed;
string stateString = await _periodEndService.GetPathItemStatesAsync(period.Year.Value, period.Period, CollectionType, cancellationToken);
var state = _stateService.GetMainState(stateString);
var startEnabled = periodClosed && !state.PeriodEndStarted;
if (PeriodEndState.CurrentAction != Constants.Action_StartPeriodEndButton)
{
await _hubContext.Clients.All.SendAsync(Constants.Action_StartPeriodEndButton, startEnabled, cancellationToken);
}
if (PeriodEndState.CurrentAction != Constants.Action_MCAReportsButton)
{
var mcaEnabled = periodClosed && !startEnabled && !state.McaReportsPublished && state.McaReportsReady;
await _hubContext.Clients.All.SendAsync(Constants.Action_MCAReportsButton, mcaEnabled, cancellationToken);
}
if (PeriodEndState.CurrentAction != Constants.Action_ProviderReportsButton)
{
var providerEnabled = periodClosed && !state.ProviderReportsPublished && state.ProviderReportsReady;
await _hubContext.Clients.All.SendAsync(Constants.Action_ProviderReportsButton, providerEnabled, cancellationToken);
}
if (PeriodEndState.CurrentAction != Constants.Action_PeriodClosedButton)
{
var closeEnabled = periodClosed && !state.PeriodEndFinished && state.McaReportsPublished && state.ProviderReportsPublished;
await _hubContext.Clients.All.SendAsync(Constants.Action_PeriodClosedButton, closeEnabled, cancellationToken);
}
}
public async Task <PeriodEndViewModel> GetPathState(int?collectionYear, int?period, CancellationToken cancellationToken)
{
var currentYearPeriod = await _periodService.ReturnPeriod(CollectionType, cancellationToken);
currentYearPeriod.Year = currentYearPeriod.Year ?? 0;
collectionYear = collectionYear ?? currentYearPeriod.Year.Value;
period = period ?? currentYearPeriod.Period;
var pathItemStates = await GetPathItemStatesAsync(collectionYear, period, CollectionType, cancellationToken);
var state = _stateService.GetMainState(pathItemStates);
var lastItemJobsFinished = _stateService.AllJobsHaveCompleted(state);
var files = await GetSubmissionsPerPeriodAsync(collectionYear.Value, period.Value, cancellationToken);
var model = new PeriodEndViewModel
{
Period = period.Value,
Year = collectionYear.Value,
Paths = state.Paths,
PeriodEndStarted = state.PeriodEndStarted,
PeriodEndFinished = state.PeriodEndFinished,
ClosePeriodEndEnabled = lastItemJobsFinished,
Files = files
};
var isCurrentPeriodSelected = currentYearPeriod.Year == model.Year && currentYearPeriod.Period == model.Period;
model.IsCurrentPeriod = isCurrentPeriodSelected;
model.CollectionClosed = isCurrentPeriodSelected && currentYearPeriod.PeriodClosed;
return(model);
}
public async Task <IActionResult> Index(int?collectionYear, int?period, CancellationToken cancellationToken)
{
var currentYearPeriod = await _periodService.ReturnPeriod(CollectionTypes.NCS, cancellationToken);
if (currentYearPeriod.Year == null)
{
throw new Exception($"Return period {currentYearPeriod.Period} has no year.");
}
var model = new PeriodEndReportViewModel();
if (collectionYear != null && period != null)
{
model.Year = collectionYear.Value;
model.Period = period.Value;
}
else
{
model.Year = currentYearPeriod.Year.Value;
model.Period = currentYearPeriod.Period;
}
model.ReportDetails = await _periodEndService.GetPeriodEndReportsAsync(model.Year, model.Period, cancellationToken);
return(View(model));
}
public async Task <IActionResult> Index(ReportsViewModel viewModel, CancellationToken cancellationToken)
{
var model = new ReportsViewModel();
ViewBag.Error = TempData["error"];
if (viewModel != null && viewModel.CollectionYear != 0)
{
model = await GenerateReportsViewModel(viewModel, cancellationToken);
}
else
{
var currentYearPeriod = await _periodService.ReturnPeriod(CollectionTypes.ILR, cancellationToken);
model.CollectionYear = currentYearPeriod.Year.GetValueOrDefault();
model.CollectionPeriod = currentYearPeriod.Period;
model = await GenerateReportsViewModel(model, cancellationToken);
}
model.ValidationReportGenerationUrl = Url.Action(nameof(RuleValidationController.ValidationRulesReport), "RuleValidation");
model.ReportsUrl = Url.Action(nameof(ReportsController.Index), "Reports");
model.ReportGenerationUrl = Url.Action(nameof(ReportsController.RunReport), "Reports");
model.ReportsDownloadUrl = Url.Action(nameof(ReportsController.GetReportFile), "Reports");
return(View(model));
}
public async Task <IActionResult> Index(int?collectionYear, int?period, CancellationToken cancellationToken)
{
var currentYearPeriod = await _periodService.ReturnPeriod(CollectionType, cancellationToken);
currentYearPeriod.Year = currentYearPeriod.Year ?? 0;
var model = new PeriodEndPrepViewModel();
if (collectionYear != null && period != null)
{
model.Year = collectionYear.Value;
model.Period = period.Value;
}
else
{
model.Year = currentYearPeriod.Year.Value;
model.Period = currentYearPeriod.Period;
}
var isCurrentPeriodSelected = currentYearPeriod.Year == model.Year && currentYearPeriod.Period == model.Period;
model.IsCurrentPeriod = isCurrentPeriodSelected;
model.Closed = (isCurrentPeriodSelected && currentYearPeriod.PeriodClosed) || (collectionYear == currentYearPeriod.Year && period < currentYearPeriod.Period) || (collectionYear <= currentYearPeriod.Year);
string state = await _periodEndService.GetPrepStateAsync(model.Year, model.Period, CollectionType, cancellationToken);
model.PeriodEndPrepModel = _stateService.GetPrepState(state);
return(View(model));
}
private async Task SetButtonStates(CancellationToken cancellationToken)
{
var period = await _periodService.ReturnPeriod(CollectionType, cancellationToken);
var periodClosed = period.PeriodClosed;
string stateString = await _periodEndService.GetPathItemStatesAsync(period.Year ?? 0, period.Period, CollectionType, cancellationToken);
var state = _stateService.GetMainState(stateString);
var startEnabled = periodClosed && !state.PeriodEndStarted && !state.PeriodEndFinished;
if (PeriodEndState.CurrentAction != Constants.Action_UploadFileButton)
{
await _hubContext.Clients.All.SendAsync(Constants.Action_UploadFileButton, !state.PeriodEndFinished, cancellationToken);
}
if (PeriodEndState.CurrentAction != Constants.Action_StartPeriodEndButton)
{
await _hubContext.Clients.All.SendAsync(Constants.Action_StartPeriodEndButton, startEnabled, cancellationToken);
}
if (PeriodEndState.CurrentAction != Constants.Action_PeriodClosedButton)
{
var closeEnabled = periodClosed && !state.PeriodEndFinished && _stateService.AllJobsHaveCompleted(state);
await _hubContext.Clients.All.SendAsync(Constants.Action_PeriodClosedButton, closeEnabled, cancellationToken);
}
}
public async Task SetButtonStates(string state, CancellationToken cancellationToken)
{
var prepModel = _stateService.GetPrepState(state);
var pauseEnabled = _stateService.PauseReferenceDataIsEnabled(prepModel.ReferenceDataJobs);
var period = await _periodService.ReturnPeriod(CollectionType, cancellationToken);
var collectionClosedEmailEnabled = period.PeriodClosed && !pauseEnabled &&
!_stateService.CollectionClosedEmailSent(prepModel.State);
var continueEnabled = !pauseEnabled && !collectionClosedEmailEnabled && period.PeriodClosed;
if (PeriodEndState.CurrentAction != Constants.Action_ReferenceJobsButton)
{
await _hubContext.Clients.All.SendAsync(Constants.Action_ReferenceJobsButton, pauseEnabled, cancellationToken);
}
if (PeriodEndState.CurrentAction != Constants.Action_CollectionClosedEmailButton)
{
await _hubContext.Clients.All.SendAsync(Constants.Action_CollectionClosedEmailButton, collectionClosedEmailEnabled, cancellationToken);
}
if (PeriodEndState.CurrentAction != Constants.Action_ContinueButton)
{
await _hubContext.Clients.All.SendAsync(Constants.Action_ContinueButton, continueEnabled, cancellationToken);
}
}
public async Task <IActionResult> Index(CancellationToken cancellationToken)
{
var ilrPeriodEndInfo = _periodService.ReturnPeriod(CollectionTypes.ILR, cancellationToken);
var ncsPeriodEndInfo = _periodService.ReturnPeriod(CollectionTypes.NCS, cancellationToken);
var allfPeriodEndInfo = _periodService.ReturnPeriod(CollectionTypes.ALLF, cancellationToken);
await Task.WhenAll(ilrPeriodEndInfo, ncsPeriodEndInfo, allfPeriodEndInfo);
var model = new PeriodEndViewModel
{
ILRPeriodEndInfo = ilrPeriodEndInfo.Result,
NCSPeriodEndInfo = ncsPeriodEndInfo.Result,
ALLFPeriodEndInfo = allfPeriodEndInfo.Result
};
return(View(model));
}
public async Task <IActionResult> Index(int?collectionYear, CancellationToken cancellationToken)
{
var currentYearPeriod = await _periodService.ReturnPeriod(CollectionTypes.ALLF, cancellationToken);
if (currentYearPeriod.Year == null)
{
throw new Exception($"Return period {currentYearPeriod.Period} has no year.");
}
var model = new HistoryViewModel
{
Year = collectionYear ?? currentYearPeriod.Year.Value
};
model.PeriodHistories = await _allfHistoryService.GetHistoryDetails(model.Year, currentYearPeriod.Period, cancellationToken);
return(View(model));
}
public async Task <IActionResult> Index(int?collectionYear, int?period, CancellationToken cancellationToken)
{
var currentYearPeriod = await _periodService.ReturnPeriod(CollectionTypes.ILR, cancellationToken);
if (currentYearPeriod.Year == null)
{
throw new Exception($"Return period {currentYearPeriod.Period} has no year.");
}
var model = new PeriodEndReportViewModel();
if (collectionYear != null && period != null)
{
model.Year = collectionYear.Value;
model.Period = period.Value;
}
else
{
model.Year = currentYearPeriod.Year.Value;
model.Period = currentYearPeriod.Period;
}
var reportDetailsTask = _periodEndService.GetPeriodEndReportsAsync(model.Year, model.Period, cancellationToken);
var sampleReportsTask = _periodEndService.GetSampleReportsAsync(model.Year, model.Period, cancellationToken);
var llvSampleReportsTask = _periodEndService.GetLLVSampleReportsAsync(model.Year, model.Period, cancellationToken);
var collectionStatsTask = _periodEndService.GetCollectionStatsAsync(model.Year, model.Period, cancellationToken);
var mcaReportsTask = _periodEndService.GetMcaReportsAsync(model.Year, model.Period, cancellationToken);
await Task.WhenAll(reportDetailsTask, sampleReportsTask, llvSampleReportsTask, collectionStatsTask, mcaReportsTask);
model.ReportDetails = reportDetailsTask.Result;
model.SampleReports = sampleReportsTask.Result;
model.LLVSampleReports = llvSampleReportsTask.Result;
model.CollectionStats = collectionStatsTask.Result;
model.McaReports = mcaReportsTask.Result;
model.SummarisationTotals = await GetSummarisationTotalsAsync(model.Year, model.Period, cancellationToken);
return(View(model));
}
public async Task <IActionResult> Index(int?collectionYear, int?period, CancellationToken cancellationToken)
{
var returnPeriod = await _periodService.ReturnPeriod(CollectionType, cancellationToken);
var years = await _periodService.GetValidityYearsAsync(CollectionType, null, cancellationToken);
var year = collectionYear ?? returnPeriod.Year ?? 0;
var periodNumber = period ?? returnPeriod.Period;
var stateString = await _periodEndService.GetPrepStateAsync(year, periodNumber, CollectionType, cancellationToken);
var state = _stateService.GetPrepState(stateString);
var model = new ValidityPeriodViewModel
{
Year = year,
Period = periodNumber,
PeriodEndInProgress = state.State.PeriodEndStarted && !state.State.PeriodEndFinished,
AllYears = years
};
return(View(model));
}
