private async Task <IDictionary <string, string> > BuildHeaderData(IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
var organisationName = await _referenceDataService.GetProviderNameAsync(reportServiceContext.Ukprn, cancellationToken) ?? string.Empty;
var easLastUpdate = await _referenceDataService.GetLastestEasSubmissionDateTimeAsync(reportServiceContext.Ukprn, cancellationToken);
var fileName = ExtractFileName(await _referenceDataService.GetLatestIlrSubmissionFileNameAsync(reportServiceContext.Ukprn, cancellationToken));
string easLastUpdateUk = null;
if (easLastUpdate != null)
{
easLastUpdateUk = _dateTimeProvider.ConvertUtcToUk(easLastUpdate.Value).LongDateStringFormat();
}
return(new Dictionary <string, string>()
{
{ SummaryPageConstants.ProviderName, organisationName },
{ SummaryPageConstants.UKPRN, reportServiceContext.Ukprn.ToString() },
{ SummaryPageConstants.ILRFile, fileName },
{ SummaryPageConstants.LastILRFileUpdate, ExtractDisplayDateTimeFromFileName(fileName) },
{ SummaryPageConstants.LastEASUpdate, easLastUpdateUk },
{ SummaryPageConstants.SecurityClassification, SummaryPageConstants.OfficialSensitive }
});
}
private IDictionary <string, string> BuildFooterData(IReportServiceContext reportServiceContext, IMessage message, ReferenceDataRoot referenceDataRoot)
{
var filePreparationDate = message?.HeaderEntity?.CollectionDetailsEntity?.FilePreparationDate.ShortDateStringFormat();
var orgVersion = referenceDataRoot.MetaDatas.ReferenceDataVersions.OrganisationsVersion.Version;
var larsVersion = referenceDataRoot.MetaDatas.ReferenceDataVersions.LarsVersion.Version;
var employersVersion = referenceDataRoot.MetaDatas.ReferenceDataVersions.Employers.Version;
var postcodesVersion = referenceDataRoot.MetaDatas.ReferenceDataVersions.PostcodesVersion.Version;
var applicationversion = reportServiceContext.ServiceReleaseVersion;
DateTime dateTimeNowUtc = _dateTimeProvider.GetNowUtc();
DateTime dateTimeNowUk = _dateTimeProvider.ConvertUtcToUk(dateTimeNowUtc);
var reportGeneratedAt = dateTimeNowUk.TimeOfDayOnDateStringFormat();
return(new Dictionary <string, string>()
{
{ SummaryPageConstants.ApplicationVersion, reportServiceContext.ServiceReleaseVersion },
{ SummaryPageConstants.FilePreparationDate, filePreparationDate },
{ SummaryPageConstants.LARSVersion, larsVersion },
{ SummaryPageConstants.PostcodeVersion, postcodesVersion },
{ SummaryPageConstants.OrganisationVersion, orgVersion },
{ SummaryPageConstants.LargeEmployersVersion, employersVersion },
{ SummaryPageConstants.ReportGeneratedAt, reportGeneratedAt }
});
}
private async Task <string> GetCsv(IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
Task <IMessage> ilrFileTask = _ilrProviderService.GetIlrFile(reportServiceContext, cancellationToken);
Task <List <string> > validLearnersTask = _validLearnersService.GetLearnersAsync(reportServiceContext, cancellationToken);
Task <FM36Global> fm36Task = _fm36ProviderService.GetFM36Data(reportServiceContext, cancellationToken);
await Task.WhenAll(ilrFileTask, validLearnersTask, fm36Task);
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
List <AppsIndicativeEarningsModel> appsIndicativeEarningsModels = new List <AppsIndicativeEarningsModel>();
if (ilrFileTask.Result?.Learners != null)
{
await GenerateRowsAsync(ilrFileTask.Result, fm36Task.Result, validLearnersTask.Result, appsIndicativeEarningsModels, cancellationToken);
}
using (var ms = new MemoryStream())
{
UTF8Encoding utF8Encoding = new UTF8Encoding(false, true);
using (TextWriter textWriter = new StreamWriter(ms, utF8Encoding))
{
using (CsvWriter csvWriter = new CsvWriter(textWriter))
{
WriteCsvRecords <AppsIndicativeEarningsMapper, AppsIndicativeEarningsModel>(csvWriter, appsIndicativeEarningsModels);
csvWriter.Flush();
textWriter.Flush();
return(Encoding.UTF8.GetString(ms.ToArray()));
}
}
}
}
public IEnumerable <UYPSummaryViewReport> Map(IReportServiceContext reportServiceContext, IEnumerable <LearnerLevelViewSummaryModel> summaryModels)
{
return(summaryModels.Select(m => new UYPSummaryViewReport
{
Ukprn = reportServiceContext.Ukprn,
ReturnPeriod = reportServiceContext.ReturnPeriod,
CoInvestmentPaymentsToCollectForThisPeriod = m.CoInvestmentPaymentsToCollectForThisPeriod,
ESFAPlannedPaymentsForThisPeriod = m.ESFAPlannedPaymentsForThisPeriod,
EarningsReleased = m.EarningsReleased,
NumberofClawbacks = m.NumberofClawbacks,
NumberofCoInvestmentsToCollect = m.NumberofCoInvestmentsToCollect,
NumberofDatalocks = m.NumberofDatalocks,
NumberofEarningsReleased = m.NumberofEarningsReleased,
NumberofHBCP = m.NumberofHBCP,
NumberofLearners = m.NumberofLearners,
NumberofOthers = m.NumberofOthers,
TotalCoInvestmentCollectedToDate = m.TotalCoInvestmentCollectedToDate,
TotalCostOfDataLocksForThisPeriod = m.TotalCostOfDataLocksForThisPeriod,
TotalCostOfHBCPForThisPeriod = m.TotalCostOfHBCPForThisPeriod,
TotalCostofClawbackForThisPeriod = m.TotalCostofClawbackForThisPeriod,
TotalCostofOthersForThisPeriod = m.TotalCostofOthersForThisPeriod,
TotalEarningsForThisPeriod = m.TotalEarningsForThisPeriod,
TotalEarningsToDate = m.TotalEarningsToDate,
TotalPaymentsToDate = m.TotalPaymentsToDate,
SummaryTotal = m.CoInvestmentPaymentsToCollectForThisPeriod.GetValueOrDefault() + m.ESFAPlannedPaymentsForThisPeriod.GetValueOrDefault()
}));
}
private async Task <IPeriodisedValuesLookup> ProvidePeriodisedValuesAsync(
IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
var fm35 = _fm35DataProvider.ProvideAsync(reportServiceContext.Ukprn, cancellationToken);
var fm25 = _fm25DataProvider.ProvideAsync(reportServiceContext.Ukprn, cancellationToken);
var fm81 = _fm81DataProvider.ProvideAsync(reportServiceContext.Ukprn, cancellationToken);
var fm99 = _fm99DataProvider.ProvideAsync(reportServiceContext.Ukprn, cancellationToken);
var eas = _easDataProvider.ProvideAsync(reportServiceContext.Ukprn, cancellationToken);
var das = _dasDataProvider.ProvideAsync(reportServiceContext.CollectionYear, reportServiceContext.Ukprn, cancellationToken);
var easdas = _dasEasDataProvider.ProvideAsync(reportServiceContext.Ukprn, cancellationToken);
await Task.WhenAll(fm35, fm25, fm81, fm99, eas, das, easdas);
var periodisedValuesLookup = new PeriodisedValuesLookup();
periodisedValuesLookup.Add(FundingDataSource.FM35, fm35.Result);
periodisedValuesLookup.Add(FundingDataSource.FM25, fm25.Result);
periodisedValuesLookup.Add(FundingDataSource.FM81, fm81.Result);
periodisedValuesLookup.Add(FundingDataSource.FM99, fm99.Result);
periodisedValuesLookup.Add(FundingDataSource.EAS, eas.Result);
periodisedValuesLookup.Add(FundingDataSource.DAS, das.Result);
periodisedValuesLookup.Add(FundingDataSource.EASDAS, easdas.Result);
return(periodisedValuesLookup);
}
private void BuildHeader(IReportServiceContext reportServiceContext, HighNeedsStudentSummaryReportModel model, string organisationName)
{
model.ProviderName = organisationName;
model.Ukprn = reportServiceContext.Ukprn.ToString();
model.IlrFile = ExtractFileName(reportServiceContext.IlrReportingFilename);
model.Year = ReportingConstants.Year;
}
public async Task <decimal?> GetCofRemoval(IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
await _getDataLock.WaitAsync(cancellationToken);
try
{
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
string ukPrnStr = reportServiceContext.Ukprn.ToString();
long ukPrn = Convert.ToInt64(ukPrnStr);
DbContextOptions <OrganisationsContext> options = new DbContextOptionsBuilder <OrganisationsContext>().UseSqlServer(_orgConfiguration.OrgConnectionString).Options;
using (OrganisationsContext organisations = new OrganisationsContext(options))
{
_cofRemoval = organisations.ConditionOfFundingRemovals.Where(x => x.Ukprn == ukPrn).OrderByDescending(x => x.EffectiveFrom).Select(x => x.CoFremoval).SingleOrDefault();
}
}
catch (Exception ex)
{
_logger.LogError("Failed to get org provider name", ex);
}
finally
{
_getDataLock.Release();
}
return(_cofRemoval);
}
public async Task <object> ProvideAsync(IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
using (var context = _easContext())
{
var easFundingLines = await context.FundingLines?
.Select(f => new EasFundingLine
{
FundLine = f.Name,
EasSubmissionValues = f.PaymentTypes
.Select(p => new EasSubmissionValue
{
PaymentName = p.PaymentName,
AdjustmentTypeName = p.AdjustmentType.Name,
}).ToList()
}).ToListAsync(cancellationToken);
var easValuesList = await context.EasSubmissions?
.Where(u => u.Ukprn == reportServiceContext.Ukprn.ToString())
.SelectMany(es => es.EasSubmissionValues
.Select(esv => new EasSubmissionDecodedValue
{
FundingLine = esv.Payment.FundingLine.Name,
AdjustmentName = esv.Payment.AdjustmentType.Name,
PaymentName = esv.Payment.PaymentName,
Period = esv.CollectionPeriod,
PaymentValue = esv.PaymentValue,
DevolvedAreaSof = esv.DevolvedAreaSoF
}))
.ToListAsync(cancellationToken);
var easValuesDictionary = BuildEasDictionary(easValuesList);
return(MapEasValues(easFundingLines, easValuesDictionary));
}
}
public async Task <IEnumerable <string> > GenerateAsync(
IReportServiceContext reportServiceContext,
IReportServiceDependentData reportsDependentData,
CancellationToken cancellationToken)
{
var fundingSummaryReportModel = _devolvedFundingSummaryReportBuilder.Build(reportServiceContext, reportsDependentData);
var fileName = _fileNameService.GetFilename(reportServiceContext, ReportName, OutputTypes.Excel);
using (var workbook = _excelService.NewWorkbook())
{
workbook.Worksheets.Clear();
foreach (var reportModel in fundingSummaryReportModel)
{
var worksheet = _excelService.GetWorksheetFromWorkbook(workbook, reportModel.SofLookup.SofCode);
_devolvedFundingSummaryReportRenderService.Render(reportModel, worksheet);
}
await _excelService.SaveWorkbookAsync(workbook, fileName, reportServiceContext.Container, cancellationToken);
}
return(new[] { fileName });
}
public async Task <DataQualityProviderModel> ProvideAsync(IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
var ukprns = new List <long>();
var collectionId = await _jobManagementDataProvider.ProvideCollectionIdAsync($"ILR{reportServiceContext.CollectionYear}");
var fileDetails = await _jobManagementDataProvider.ProvideFilePeriodInfoForCollectionAsync(collectionId);
var ruleViolations = await _ilrDataProvider.ProvideTop20RuleViolationsAsync();
var validationRules = await _ilrRefDataProvider.ProvideAsync(cancellationToken);
var providersWithoutValidLearners = await _ilrDataProvider.ProvideProvidersWithoutValidLearners(cancellationToken);
var providersWithMostInvalidLearners = await _ilrDataProvider.ProvideProvidersWithMostInvalidLearners(cancellationToken);
ukprns.AddRange(providersWithoutValidLearners.Select(x => x.Ukprn));
ukprns.AddRange(providersWithMostInvalidLearners.Select(x => x.Ukprn));
var organisations = await _organisationDataProvider.ProvideAsync(ukprns);
return(new DataQualityProviderModel
{
CollectionId = collectionId, FileDetails = fileDetails, RuleViolations = ruleViolations,
ProvidersWithoutValidLearners = providersWithoutValidLearners,
ProvidersWithMostInvalidLearners = providersWithMostInvalidLearners,
Organistions = organisations,
ValidationRules = validationRules
});
}
public IEnumerable <HighNeedsStudentDetailReportModel> Build(IReportServiceContext reportServiceContext, IReportServiceDependentData reportServiceDependentData)
{
var message = reportServiceDependentData.Get <IMessage>();
var fm25 = reportServiceDependentData.Get <FM25Global>();
var fm25LearnerDictionary = BuildFm25LearnerDictionary(fm25);
var models = new List <HighNeedsStudentDetailReportModel>();
foreach (var learner in message?.Learners ?? Enumerable.Empty <ILearner>())
{
var fm25Learner = fm25LearnerDictionary.GetValueOrDefault(learner.LearnRefNumber);
if (Filter(learner, fm25Learner))
{
var ehc = FamCodeForType(learner.LearnerFAMs, LearnerFAMTypeConstants.EHC);
var hns = FamCodeForType(learner.LearnerFAMs, LearnerFAMTypeConstants.HNS);
models.Add(new HighNeedsStudentDetailReportModel()
{
Learner = learner,
FM25Learner = fm25Learner,
DerivedFundline = _derivedFundLineDictionary.GetValueOrDefault(fm25Learner.FundLine),
StudentsWithAnEhcp = StudentWithAnEhcp(ehc),
StudentsWithoutAnEhcp = StudentWithoutAnEhcp(ehc),
HighNeedsStudentsWithoutAnEhcp = HighNeedsStudentWithoutAnEhcp(hns, ehc),
StudentsWithAnEhcpAndHns = StudentWithAnEhcpAndHns(hns, ehc),
StudentWithAnEhcpAndNotHns = StudentWithAnEhcpAndNotHns(hns, ehc),
});
}
}
return(Order(models));
}
public async Task <IPeriodisedValuesLookup> ProvideAsync(IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
var ukprn = reportServiceContext.Ukprn;
var fm35 = BuildFm35DictionaryAsync(ukprn, cancellationToken);
var fm25 = BuildFm25DictionaryAsync(ukprn, cancellationToken);
var fm81 = BuildFm81DictionaryAsync(ukprn, cancellationToken);
var fm99 = BuildFm99DictionaryAsync(ukprn, cancellationToken);
var eas = BuildEasDictionaryAsync(ukprn, cancellationToken);
var das = BuildDasDictionaryAsync(ukprn, cancellationToken);
var easdas = BuildEasDasDictionaryAsync(ukprn, cancellationToken);
await Task.WhenAll(fm35, fm25, fm81, fm99, eas, das, easdas);
var periodisedValuesLookup = new PeriodisedValuesLookup();
periodisedValuesLookup.Add(FundingDataSource.FM35, fm35.Result);
periodisedValuesLookup.Add(FundingDataSource.FM25, fm25.Result);
periodisedValuesLookup.Add(FundingDataSource.FM81, fm81.Result);
periodisedValuesLookup.Add(FundingDataSource.FM99, fm99.Result);
periodisedValuesLookup.Add(FundingDataSource.EAS, eas.Result);
periodisedValuesLookup.Add(FundingDataSource.DAS, das.Result);
periodisedValuesLookup.Add(FundingDataSource.EASDAS, easdas.Result);
return(periodisedValuesLookup);
}
public FundingClaimReportModel Build(IReportServiceContext reportServiceContext, IReportServiceDependentData reportServiceDependentData)
{
var message = reportServiceDependentData.Get <IMessage>();
var fm25Data = reportServiceDependentData.Get <FM25Global>();
var referenceDataRoot = reportServiceDependentData.Get <ReferenceDataRoot>();
var referenceDateFilter = RetrieveReportFilterValueFromContext <DateTime?>(reportServiceContext, ReportNameConstants.SixteenNineteenFundingClaim, ReportingConstants.ReferenceDateFilterPropertyName);
var organisation = referenceDataRoot.Organisations.FirstOrDefault(o => o.UKPRN == reportServiceContext.Ukprn);
var learners = message?.Learners ?? Enumerable.Empty <ILearner>();
var model = new FundingClaimReportModel();
var applicableLearners = FilterLearners(learners);
// Header
var referenceDate = referenceDateFilter.HasValue ? referenceDateFilter.Value.ShortDateStringFormat() : "(ALL)";
BuildHeader(reportServiceContext, model, organisation, referenceDate);
// Body
BuildBody(model, fm25Data.Learners, applicableLearners, referenceDateFilter);
// Footer
BuildFooter(model, referenceDataRoot.MetaDatas.ReferenceDataVersions, reportServiceContext.ServiceReleaseVersion, message?.HeaderEntity.CollectionDetailsEntity.FilePreparationDate);
return(model);
}
private async Task <bool> GenerateReportAsync(string task, IReportServiceContext reportServiceContext, ZipArchive archive, CancellationToken cancellationToken)
{
bool needZip = false;
bool foundReport = false;
foreach (var report in _reports)
{
if (!report.IsMatch(task))
{
continue;
}
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
_logger.LogDebug($"Attempting to generate {report.GetType().Name}", jobIdOverride: reportServiceContext.JobId);
needZip = await report.GenerateReport(reportServiceContext, archive, cancellationToken);
stopWatch.Stop();
_logger.LogDebug($"Persisted {report.GetType().Name} to csv/json in: {stopWatch.ElapsedMilliseconds}", jobIdOverride: reportServiceContext.JobId);
foundReport = true;
break;
}
if (!foundReport)
{
_logger.LogDebug($"Unable to find Data Match report '{task}'", jobIdOverride: reportServiceContext.JobId);
}
return(needZip);
}
public AEBSTFFundingSummaryReportModel Build(IReportServiceContext reportServiceContext, IReportServiceDependentData reportServiceDependentData)
{
var message = reportServiceDependentData.Get <IMessage>();
var referenceDataRoot = reportServiceDependentData.Get <ReferenceDataRoot>();
var periodisedValues = _periodisedValuesLookupProvider.Provide(FundingDataSources, reportServiceDependentData);
var reportCurrentPeriod = reportServiceContext.ReturnPeriod > 12 ? 12 : reportServiceContext.ReturnPeriod;
var description = "ESFA AEB - Short Term Funding Initiative";
return(new AEBSTFFundingSummaryReportModel(
BuildHeaderData(reportServiceContext, referenceDataRoot),
new List <IFundingCategory>()
{
new FundingCategory(
@"ESFA Adult Education Budget - Short Term Funding Initiatives", reportCurrentPeriod,
new List <IFundingSubCategory>()
{
new FundingSubCategory($@"{description} 1", reportCurrentPeriod)
.WithFundLineGroup(BuildIlrStfiFundLineGroup($@"{description} 1", reportCurrentPeriod, new [] { FundLineConstants.STFI1 }, periodisedValues))
.WithFundLineGroup(BuildEasStfiFundLineGroup($@"{description} 1", reportCurrentPeriod, new [] { FundLineConstants.STFI1 }, periodisedValues)),
new FundingSubCategory($@"{description} 2", reportCurrentPeriod)
.WithFundLineGroup(BuildIlrStfiFundLineGroup($@"{description} 2", reportCurrentPeriod, new [] { FundLineConstants.STFI2 }, periodisedValues))
.WithFundLineGroup(BuildEasStfiFundLineGroup($@"{description} 2", reportCurrentPeriod, new [] { FundLineConstants.STFI2 }, periodisedValues)),
new FundingSubCategory($@"{description} 3", reportCurrentPeriod)
.WithFundLineGroup(BuildIlrStfiFundLineGroup($@"{description} 3", reportCurrentPeriod, new [] { FundLineConstants.STFI3 }, periodisedValues))
.WithFundLineGroup(BuildEasStfiFundLineGroup($@"{description} 3", reportCurrentPeriod, new [] { FundLineConstants.STFI3 }, periodisedValues)),
new FundingSubCategory($@"{description} 4", reportCurrentPeriod)
.WithFundLineGroup(BuildIlrStfiFundLineGroup($@"{description} 4", reportCurrentPeriod, new [] { FundLineConstants.STFI4 }, periodisedValues))
.WithFundLineGroup(BuildEasStfiFundLineGroup($@"{description} 4", reportCurrentPeriod, new [] { FundLineConstants.STFI4 }, periodisedValues))
})
},
BuildFooterData(reportServiceContext, message, referenceDataRoot)));
}
public async Task <IReadOnlyCollection <IPreviousYearLearner> > ProvideAsync(IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
using (var connection = _sqlConnectionFunc())
{
using (var results = await connection.QueryMultipleAsync(_sql, new { ukprn = reportServiceContext.Ukprn, currentYearStart = _currentYearStart }))
{
var learners = (await results.ReadAsync <PreviousYearLearner>()).ToList();
var learnDelFAMS = (await results.ReadAsync <LearningDeliveryFAM>()).GroupBy(x => x.LearnRefNumber, StringComparer.OrdinalIgnoreCase).ToDictionary(x => x.Key, x => x.GroupBy(y => y.AimSeqNumber).ToDictionary(d => d.Key, d => d));
var provSpecLearnMon = (await results.ReadAsync <ProviderSpecLearnerMonitoring>()).GroupBy(x => x.LearnRefNumber, StringComparer.OrdinalIgnoreCase).ToDictionary(x => x.Key, x => x, StringComparer.OrdinalIgnoreCase);
var provSpecDelMon = (await results.ReadAsync <ProviderSpecDeliveryMonitoring>()).GroupBy(x => x.LearnRefNumber, StringComparer.OrdinalIgnoreCase).ToDictionary(x => x.Key, x => x.GroupBy(y => y.AimSeqNumber).ToDictionary(d => d.Key, d => d));
foreach (var learner in learners)
{
learner.LearningDeliveryFAMs = learnDelFAMS.GetValueOrDefault(learner.LearnRefNumber)
.GetValueOrDefault(learner.AimSeqNumber).ToList();
learner.ProviderSpecLearnerMonitorings = provSpecLearnMon.GetValueOrDefault(learner.LearnRefNumber).ToList();
learner.ProvSpecDeliveryMonitorings = provSpecDelMon.GetValueOrDefault(learner.LearnRefNumber)
.GetValueOrDefault(learner.AimSeqNumber).ToList();
}
return(learners.ToList());
}
}
}
public async Task <IReportServiceContext> MutateAsync(IReportServiceContext reportServiceContext, IReportServiceDependentData reportServiceDependentData, CancellationToken cancellationToken)
{
await AddIlrReportingFilename(reportServiceContext, cancellationToken);
await AddEasReportingFilename(reportServiceContext, reportServiceDependentData, cancellationToken);
return(reportServiceContext);
}
public async Task <string> GenerateReport(IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
if (!_reportGenerationPeriods.Contains(reportServiceContext.ReturnPeriod))
{
return(string.Empty);
}
IncludeInZip = reportServiceContext.PublishReportToZip;
var fileName = _fileNameService.GetFilename(reportServiceContext, ReportName, OutputTypes.Excel);
var data = await _crossYearDataProvider.ProvideAsync(reportServiceContext, cancellationToken);
var model = _crossYearModelBuilder.Build(data, reportServiceContext);
var assembly = Assembly.GetExecutingAssembly();
string resourceName = assembly.GetManifestResourceNames().Single(str => str.EndsWith(TemplateName));
using (Stream manifestResourceStream = assembly.GetManifestResourceStream(resourceName))
using (var workbook = _excelFileService.GetWorkbookFromTemplate(manifestResourceStream))
{
var worksheet = _excelFileService.GetWorksheetFromWorkbook(workbook, WorksheetName);
_crossYearRenderService.Render(reportServiceContext, model, worksheet, workbook);
await _excelFileService.SaveWorkbookAsync(workbook, fileName, reportServiceContext.Container, cancellationToken);
}
return(fileName);
}
private async Task AddEasReportingFilename(IReportServiceContext reportServiceContext, IReportServiceDependentData reportServiceDependentData, CancellationToken cancellationToken)
{
var referenceDataEASFile = new EasFileDetails();
if (reportServiceDependentData.Contains <ReferenceDataRoot>())
{
referenceDataEASFile = reportServiceDependentData.Get <ReferenceDataRoot>()?.MetaDatas.ReferenceDataVersions.EasFileDetails;
}
var easFileName = !string.IsNullOrWhiteSpace(referenceDataEASFile?.FileName) && referenceDataEASFile.FileName != _defaultEASValue?Path.GetFileName(referenceDataEASFile?.FileName) : _defaultEASValue;
reportServiceContext.EasReportingFilename = easFileName;
if (referenceDataEASFile?.UploadDateTime != null)
{
var easLastUpdated = (DateTime)referenceDataEASFile?.UploadDateTime.Value;
reportServiceContext.LastEasFileUpdate = _dateTimeProvider.ConvertUtcToUk(easLastUpdated).ToString(ReportServiceConstants.LastFileUpdateDateTimeFormat);
}
if (referenceDataEASFile?.UploadDateTime == null)
{
reportServiceContext.LastEasFileUpdate = _defaultEASValue;
}
}
public HighNeedsStudentSummaryReportModel Build(IReportServiceContext reportServiceContext, IReportServiceDependentData reportServiceDependentData)
{
var message = reportServiceDependentData.Get <IMessage>();
var fm25Data = reportServiceDependentData.Get <FM25Global>();
var referenceDataRoot = reportServiceDependentData.Get <ReferenceDataRoot>();
var organisationName = referenceDataRoot.Organisations.FirstOrDefault(o => o.UKPRN == reportServiceContext.Ukprn)?.Name ?? string.Empty;
var learners = message?.Learners ?? Enumerable.Empty <ILearner>();
var model = new HighNeedsStudentSummaryReportModel();
var applicableLearners = learners.Where(LearnerFilter).ToList();
var applicableStudyProgrammeLearners = fm25Data.Learners?.Where(x => x.StartFund == true && StudyProgrammePredicate(x)).ToList();
var applicableTLevelLearners = fm25Data.Learners?.Where(x => x.StartFund == true && TLevelPredicate(x)).ToList();
// Header
BuildHeader(reportServiceContext, model, organisationName);
// Body
model.StudyProgramme = BuildBody(applicableStudyProgrammeLearners, applicableLearners);
model.TLevel = BuildBody(applicableTLevelLearners, applicableLearners);
// Footer
BuildFooter(model, referenceDataRoot.MetaDatas.ReferenceDataVersions, reportServiceContext.ServiceReleaseVersion, message?.HeaderEntity.CollectionDetailsEntity.FilePreparationDate);
return(model);
}
public async Task CreateOrUpdateZipWithReportAsync(string reportFileNameKey, IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(reportFileNameKey))
{
return;
}
var reportZipFileKey = _fileNameService.GetFilename(reportServiceContext, ReportsZipName, OutputTypes.Zip, false);
using (var memoryStream = new MemoryStream())
using (var zipSteam = await GetStreamAsync(reportZipFileKey, reportServiceContext, cancellationToken))
{
await zipSteam.CopyToAsync(memoryStream, BufferSize, cancellationToken);
using (var zipArchive = new ZipArchive(memoryStream, ZipArchiveMode.Update, true))
{
using (var readStream = await _fileService.OpenReadStreamAsync(reportFileNameKey, reportServiceContext.Container, cancellationToken))
{
await _zipArchiveService.AddEntryToZip(zipArchive, readStream, PrepareFileName(reportFileNameKey), cancellationToken);
}
}
using (var writeStream = await _fileService.OpenWriteStreamAsync(reportZipFileKey, reportServiceContext.Container, cancellationToken))
{
memoryStream.Position = 0;
await memoryStream.CopyToAsync(writeStream, BufferSize, cancellationToken);
}
}
}
private async Task GenerateReportAsync(string task, IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
var foundReport = false;
foreach (var report in _internalReports)
{
if (!report.IsMatch(task))
{
continue;
}
var stopWatch = new Stopwatch();
stopWatch.Start();
_logger.LogDebug($"Attempting to generate internal report {report.GetType().Name}");
await report.GenerateReport(reportServiceContext, cancellationToken);
stopWatch.Stop();
_logger.LogDebug($"Persisted {report.GetType().Name} to csv/json/xlsx in: {stopWatch.ElapsedMilliseconds}");
foundReport = true;
break;
}
if (!foundReport)
{
_logger.LogDebug($"Unable to find report '{task}'");
}
}
public async Task <bool> Callback(IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
_logger.LogInfo("Reporting callback invoked");
var reportZipFileKey = $"{reportServiceContext.Ukprn}_{reportServiceContext.JobId}_Reports.zip";
cancellationToken.ThrowIfCancellationRequested();
MemoryStream memoryStream = new MemoryStream();
var zipFileExists = await _streamableKeyValuePersistenceService.ContainsAsync(reportZipFileKey, cancellationToken);
if (zipFileExists)
{
await _streamableKeyValuePersistenceService.GetAsync(reportZipFileKey, memoryStream, cancellationToken);
}
using (memoryStream)
{
using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Update, true))
{
await ExecuteTasks(reportServiceContext, archive, cancellationToken);
}
await _streamableKeyValuePersistenceService.SaveAsync(reportZipFileKey, memoryStream, cancellationToken);
}
return(true);
}
public IEnumerable <LearnerLevelViewReport> Map(IReportServiceContext reportServiceContext, IEnumerable <LearnerLevelViewModel> learnerLevelViewRecords, CancellationToken cancellationToken)
{
return(learnerLevelViewRecords.Select(m => new LearnerLevelViewReport
{
Ukprn = reportServiceContext.Ukprn,
PaymentLearnerReferenceNumber = m.PaymentLearnerReferenceNumber,
PaymentUniqueLearnerNumber = long.Parse(m.PaymentUniqueLearnerNumbers.Split(';')[0]),
FamilyName = m.FamilyName,
GivenNames = m.GivenNames,
LearnerEmploymentStatusEmployerId = m.LearnerEmploymentStatusEmployerId,
EmployerName = m.EmployerName,
TotalEarningsToDate = m.TotalEarningsToDate,
PlannedPaymentsToYouToDate = m.PlannedPaymentsToYouToDate,
TotalCoInvestmentCollectedToDate = m.TotalCoInvestmentCollectedToDate,
CoInvestmentOutstandingFromEmplToDate = m.CoInvestmentOutstandingFromEmplToDate,
TotalEarningsForPeriod = m.TotalEarningsForPeriod,
ESFAPlannedPaymentsThisPeriod = m.ESFAPlannedPaymentsThisPeriod,
CoInvestmentPaymentsToCollectThisPeriod = m.CoInvestmentPaymentsToCollectThisPeriod,
IssuesAmount = m.IssuesAmount,
ReasonForIssues = m.ReasonForIssues,
PaymentFundingLineType = m.PaymentFundingLineType,
RuleDescription = m.RuleDescription,
ReturnPeriod = reportServiceContext.ReturnPeriod
}));
}
public async Task <IReadOnlyCollection <IMcaGlaSofLookup> > ProvideAsync(IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
using (var connection = _sqlConnectionFunc())
{
return((await connection.QueryAsync <McaGlaSofLookup>(_sql, cancellationToken)).ToList());
}
}
public IEnumerable <FundingSummaryReport> Map(IReportServiceContext reportServiceContext, FundingSummaryReportModel fundingSummaryReportModel, CancellationToken cancellationToken)
{
var persistModels = fundingSummaryReportModel.FundingCategories.SelectMany(fc => fc.FundingSubCategories.SelectMany(fsc =>
fsc.FundLineGroups.SelectMany(flg => flg.FundLines.Select(fl => new FundingSummaryReport
{
Ukprn = reportServiceContext.Ukprn,
ReturnPeriod = reportServiceContext.ReturnPeriod,
ContractNo = fc.ContractAllocationNumber,
FundingCategory = fc.FundingCategoryTitle,
FundingSubCategory = fsc.FundingSubCategoryTitle,
FundLine = fl.Title,
Aug20 = fl.Period1,
Sep20 = fl.Period2,
Oct20 = fl.Period3,
Nov20 = fl.Period4,
Dec20 = fl.Period5,
Jan21 = fl.Period6,
Feb21 = fl.Period7,
Mar21 = fl.Period8,
Apr21 = fl.Period9,
May21 = fl.Period10,
Jun21 = fl.Period11,
Jul21 = fl.Period12,
AugMar = fl.Period1To8,
AprJul = fl.Period9To12,
YearToDate = fl.YearToDate,
Total = fl.Total
})))).ToList();
return(persistModels);
}
public async Task <string> GenerateAsync(IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
var fileName = _fileNameService.GetFilename(reportServiceContext, FileName, OutputTypes.Excel);
var reportData = await _reportDataProvider.ProvideAsync(reportServiceContext, cancellationToken);
using (var workbook = _excelFileService.NewWorkbook())
{
workbook.Worksheets.Clear();
var summaries = new List <ISummaryRow>();
var summaryWorksheet = _excelFileService.GetWorksheetFromWorkbook(workbook, SummaryName);
foreach (var worksheetTask in reportServiceContext.Tasks)
{
var worksheet = _worksheets.GetValueOrDefault(worksheetTask);
summaries.Add(worksheet.Generate(workbook, reportServiceContext, reportData, cancellationToken));
}
var summaryModel = _summaryPageModelBuilder.Build(reportServiceContext, reportData);
summaryModel.SummaryRows = summaries;
_summarPageRenderService.Render(summaryModel, summaryWorksheet);
await _excelFileService.SaveWorkbookAsync(workbook, fileName, reportServiceContext.Container, cancellationToken);
}
return(fileName);
}
public EntryPoint(IImmutableDictionary <string, IReport> reports, IReportServiceContext reportServiceContext, IReportZipService reportZipService, ILogger logger)
{
_reports = reports;
_reportServiceContext = reportServiceContext;
_reportZipService = reportZipService;
_logger = logger;
}
public IEnumerable <MathsAndEnglishReportModel> Build(IReportServiceContext reportServiceContext, IReportServiceDependentData reportServiceDependentData)
{
var message = reportServiceDependentData.Get <IMessage>();
var fm25 = reportServiceDependentData.Get <FM25Global>();
var fm25LearnerDictionary = BuildFm25LearnerDictionary(fm25);
var models = new List <MathsAndEnglishReportModel>();
foreach (var learner in message?.Learners ?? Enumerable.Empty <ILearner>())
{
var fm25Learner = fm25LearnerDictionary.GetValueOrDefault(learner.LearnRefNumber);
if (Filter(learner, fm25Learner))
{
models.Add(new MathsAndEnglishReportModel()
{
Learner = learner,
FM25Learner = fm25Learner,
});
}
}
return(Order(models));
}
public async Task <IMessage> GetIlrFile(IReportServiceContext reportServiceContext, CancellationToken cancellationToken)
{
await _getIlrLock.WaitAsync(cancellationToken);
try
{
if (_message != null)
{
return(_message);
}
cancellationToken.ThrowIfCancellationRequested();
string filename = reportServiceContext.Filename;
int ukPrn = reportServiceContext.Ukprn;
if (string.Equals(reportServiceContext.CollectionName, "ILR1819", StringComparison.OrdinalIgnoreCase))
{
using (MemoryStream ms = new MemoryStream())
{
await _storage.GetAsync(filename, ms, cancellationToken);
ms.Seek(0, SeekOrigin.Begin);
_message = _xmlSerializationService.Deserialize <Message>(ms);
}
}
else
{
DateTime submittedDate;
DateTime filePreparationDate;
using (var ilrContext = _ilrValidContextFactory())
{
submittedDate = ilrContext.Sources.SingleOrDefault(x => x.UKPRN == ukPrn)?.DateTime ?? _dateTimeProvider.ConvertUtcToUk(_dateTimeProvider.GetNowUtc());
filePreparationDate = ilrContext.CollectionDetails.SingleOrDefault(x => x.UKPRN == ukPrn)?.FilePreparationDate ?? _dateTimeProvider.ConvertUtcToUk(_dateTimeProvider.GetNowUtc());
}
_message = new Message
{
Header = new MessageHeader
{
Source = new MessageHeaderSource
{
UKPRN = ukPrn,
DateTime = submittedDate
},
CollectionDetails = new MessageHeaderCollectionDetails
{
FilePreparationDate = filePreparationDate
}
}
};
}
}
finally
{
_getIlrLock.Release();
}
return(_message);
}
public OrdersRepository(IUnitOfWork uow)
{
_context = uow.Context as IReportServiceContext;
}
