public IDictionary <string, ILooseLearner> BuildLearnerDictionary(ILooseMessage message)
{
return(message?
.Learners?
.Where(l => l.LearnRefNumber != null)
.GroupBy(l => l.LearnRefNumber.Trim(), StringComparer.OrdinalIgnoreCase)
.ToDictionary(l => l.Key, l => l.FirstOrDefault(), StringComparer.OrdinalIgnoreCase)
?? new Dictionary <string, ILooseLearner>());
}
public void MapInvalidLearnerData(IDataStoreCache cache, ILooseMessage ilr, IEnumerable <string> learnersValid)
{
var ukprn = ilr.LearningProviderEntity.UKPRN;
var header = ilr.HeaderEntity;
var sourceFileCollection = ilr.SourceFilesCollection;
var learners = ilr.Learners?.Where(l => !learnersValid.Contains(!string.IsNullOrWhiteSpace(l.LearnRefNumber) ? l.LearnRefNumber.Trim() : string.Empty, StringComparer.OrdinalIgnoreCase));
var learnerDestinationAndProgressions = ilr.LearnerDestinationAndProgressions?.Where(ldp => !learnersValid.Contains(!string.IsNullOrWhiteSpace(ldp.LearnRefNumber) ? ldp.LearnRefNumber.Trim() : string.Empty, StringComparer.OrdinalIgnoreCase));
PopulateInvalidLearners(cache, ukprn, header, sourceFileCollection, learners, learnerDestinationAndProgressions);
}
public async Task <IEnumerable <string> > GenerateAsync(IReportServiceContext reportServiceContext, IReportServiceDependentData reportsDependentData, CancellationToken cancellationToken)
{
ILooseMessage ilrMessage = reportsDependentData.Get <ILooseMessage>();
ReferenceDataRoot ilrReferenceData = reportsDependentData.Get <ReferenceDataRoot>();
List <ValidationError> ilrValidationErrors = reportsDependentData.Get <List <ValidationError> >();
var fileName = _fileNameService.GetFilename(reportServiceContext, ReportName, OutputTypes.Csv);
var validationErrorRows = _validationErrorsReportBuilder.Build(ilrValidationErrors, ilrMessage, ilrReferenceData.MetaDatas.ValidationErrors);
await _csvService.WriteAsync <ValidationErrorRow, ValidationErrorMapper>(validationErrorRows, fileName, reportServiceContext.Container, cancellationToken);
await _frontEndValidationReport.GenerateAsync(reportServiceContext, validationErrorRows, false, cancellationToken);
return(new[] { fileName });
}
public IEnumerable <ValidationErrorRow> Build(
IEnumerable <ValidationError> ilrValidationErrors,
ILooseMessage message,
IReadOnlyCollection <Models.ReferenceData.MetaData.ValidationError> validationErrorsMetadata)
{
List <ValidationErrorRow> validationErrorModels = new List <ValidationErrorRow>();
var learnerDictionary = BuildLearnerDictionary(message);
foreach (ValidationError validationError in ilrValidationErrors)
{
ILooseLearner learner = learnerDictionary?.GetValueOrDefault(validationError.LearnerReferenceNumber?.Trim());
ILooseLearningDelivery learningDelivery = learner?.LearningDeliveries?.FirstOrDefault(x => x.AimSeqNumberNullable == validationError.AimSequenceNumber);
validationErrorModels.Add(new ValidationErrorRow()
{
AimSequenceNumber = validationError.AimSequenceNumber,
ULN = learner?.ULNNullable,
FamilyName = learner?.FamilyName,
GivenNames = learner?.GivenNames,
ErrorMessage = validationErrorsMetadata.FirstOrDefault(x => x.RuleName.CaseInsensitiveEquals(validationError.RuleName))?.Message,
FieldValues = validationError.ValidationErrorParameters == null
? string.Empty
: GetValidationErrorParameters(validationError.ValidationErrorParameters),
FundModel = learningDelivery?.FundModelNullable,
LearnAimRef = learningDelivery?.LearnAimRef,
LearnerReferenceNumber = validationError.LearnerReferenceNumber,
PartnerUKPRN = learningDelivery?.PartnerUKPRNNullable,
ProviderSpecDelOccurA = learningDelivery?.ProviderSpecDeliveryMonitorings?.FirstOrDefault(x => x.ProvSpecDelMonOccur.CaseInsensitiveEquals("A"))?.ProvSpecDelMon,
ProviderSpecDelOccurB = learningDelivery?.ProviderSpecDeliveryMonitorings?.FirstOrDefault(x => x.ProvSpecDelMonOccur.CaseInsensitiveEquals("B"))?.ProvSpecDelMon,
ProviderSpecDelOccurC = learningDelivery?.ProviderSpecDeliveryMonitorings?.FirstOrDefault(x => x.ProvSpecDelMonOccur.CaseInsensitiveEquals("C"))?.ProvSpecDelMon,
ProviderSpecDelOccurD = learningDelivery?.ProviderSpecDeliveryMonitorings?.FirstOrDefault(x => x.ProvSpecDelMonOccur.CaseInsensitiveEquals("D"))?.ProvSpecDelMon,
ProviderSpecLearnOccurA = learner?.ProviderSpecLearnerMonitorings?.FirstOrDefault(x => x.ProvSpecLearnMonOccur.CaseInsensitiveEquals("A"))?.ProvSpecLearnMon,
ProviderSpecLearnOccurB = learner?.ProviderSpecLearnerMonitorings?.FirstOrDefault(x => x.ProvSpecLearnMonOccur.CaseInsensitiveEquals("B"))?.ProvSpecLearnMon,
RuleName = validationError.RuleName,
SWSupAimId = learningDelivery?.SWSupAimId,
Severity = validationError.Severity
});
}
return(validationErrorModels
.OrderBy(e => e.Severity)
.ThenBy(e => e.RuleName));
}
public RuleViolationSummaryReportModel Build(IReportServiceContext reportServiceContext, IReportServiceDependentData reportServiceDependentData)
{
ILooseMessage looseMessage = reportServiceDependentData.Get <ILooseMessage>();
ReferenceDataRoot referenceDataRoot = reportServiceDependentData.Get <ReferenceDataRoot>();
List <ValidationError> validationErrors = reportServiceDependentData.Get <List <ValidationError> >();
var validationErrorMessageDictionary = referenceDataRoot.MetaDatas.ValidationErrors.ToDictionary(ve => ve.RuleName, ve => ve.Message, StringComparer.OrdinalIgnoreCase);
var model = new RuleViolationSummaryReportModel();
var organisation = referenceDataRoot.Organisations.FirstOrDefault(o => o.UKPRN == reportServiceContext.Ukprn);
var organisationName = organisation?.Name ?? string.Empty;
DateTime dateTimeNowUtc = _dateTimeProvider.GetNowUtc();
DateTime dateTimeNowUk = _dateTimeProvider.ConvertUtcToUk(dateTimeNowUtc);
var reportGeneratedAt = "Report generated at: " + FormatReportGeneratedAtDateTime(dateTimeNowUk);
var looseLearners = looseMessage?.Learners?.ToList() ?? new List <ILooseLearner>();
var looseLearnerDestinationAndProgressions = looseMessage?.LearnerDestinationAndProgressions?.ToList() ?? new List <ILooseLearnerDestinationAndProgression>();
// Header
model.ProviderName = $"Provider: {organisationName}";
model.Ukprn = $"UKPRN: {reportServiceContext.Ukprn}";
model.IlrFile = $"ILR File: {ExtractFileName(reportServiceContext.IlrReportingFilename)}";
model.Year = ReportingConstants.Year;
// body
var validationErrorsList = validationErrors.Where(x => x.Severity.CaseInsensitiveEquals(Error)).ToList();
var validationErrorWarningsList = validationErrors.Where(x => x.Severity.CaseInsensitiveEquals(Warning)).ToList();
var learnRefNumbersWithErrors = new HashSet <string>(validationErrorsList.Select(x => x.LearnerReferenceNumber), StringComparer.OrdinalIgnoreCase);
var learnRefNumbersWithWarnings = new HashSet <string>(validationErrorWarningsList.Select(x => x.LearnerReferenceNumber), StringComparer.OrdinalIgnoreCase);
var validLearners = looseLearners.Where(l => !learnRefNumbersWithErrors.Contains(l.LearnRefNumber)).ToList();
var invalidLearners = looseLearners.Where(l => learnRefNumbersWithErrors.Contains(l.LearnRefNumber)).ToList();
var validLearnerDestinationAndProgressions = looseLearnerDestinationAndProgressions.Where(ldp => !learnRefNumbersWithErrors.Contains(ldp.LearnRefNumber)).ToList();
var invalidLearnerDestinationAndProgressions = looseLearnerDestinationAndProgressions.Where(ldp => learnRefNumbersWithErrors.Contains(ldp.LearnRefNumber)).ToList();
model.TotalNoOfErrors = validationErrorsList.Count;
model.TotalNoOfWarnings = validationErrorWarningsList.Count;
model.TotalNoOfLearners = looseLearners.DistinctByCount(x => x.LearnRefNumber);
model.TotalNoOfLearnersWithWarnings = learnRefNumbersWithWarnings.Count(l => !learnRefNumbersWithErrors.Contains(l));
var learningDeliveries = looseLearners.Where(x => x.LearningDeliveries != null).SelectMany(x => x.LearningDeliveries).ToList();
model.FullyValidLearners = new RuleViolationsTotalModel
{
Total = validLearners.DistinctByCount(x => x.LearnRefNumber),
Apprenticeships = LearnersWithFundModelLearningDeliveryFundModelCount(validLearners, FundModelConstants.FM36),
Funded1619 = LearnersWithFundModelLearningDeliveryFundModelCount(validLearners, FundModelConstants.FM25),
AdultSkilledFunded = LearnersWithFundModelLearningDeliveryFundModelCount(validLearners, FundModelConstants.FM35),
CommunityLearningFunded = LearnersWithFundModelLearningDeliveryFundModelCount(validLearners, FundModelConstants.FM10),
ESFFunded = LearnersWithFundModelLearningDeliveryFundModelCount(validLearners, FundModelConstants.FM70),
OtherAdultFunded = LearnersWithFundModelLearningDeliveryFundModelCount(validLearners, FundModelConstants.FM81),
Other1619Funded = LearnersWithFundModelLearningDeliveryFundModelCount(validLearners, FundModelConstants.FM82),
NonFunded = LearnersWithFundModelLearningDeliveryFundModelCount(validLearners, FundModelConstants.FM99)
};
model.InvalidLearners = new RuleViolationsTotalModel
{
Total = invalidLearners.DistinctByCount(x => x.LearnRefNumber),
Apprenticeships = LearnersWithFundModelLearningDeliveryFundModelCount(invalidLearners, FundModelConstants.FM36),
Funded1619 = LearnersWithFundModelLearningDeliveryFundModelCount(invalidLearners, FundModelConstants.FM25),
AdultSkilledFunded = LearnersWithFundModelLearningDeliveryFundModelCount(invalidLearners, FundModelConstants.FM35),
CommunityLearningFunded = LearnersWithFundModelLearningDeliveryFundModelCount(invalidLearners, FundModelConstants.FM10),
ESFFunded = LearnersWithFundModelLearningDeliveryFundModelCount(invalidLearners, FundModelConstants.FM70),
OtherAdultFunded = LearnersWithFundModelLearningDeliveryFundModelCount(invalidLearners, FundModelConstants.FM81),
Other1619Funded = LearnersWithFundModelLearningDeliveryFundModelCount(invalidLearners, FundModelConstants.FM82),
NonFunded = LearnersWithFundModelLearningDeliveryFundModelCount(invalidLearners, FundModelConstants.FM99)
};
model.LearningDeliveries = new RuleViolationsTotalModel
{
Total = learningDeliveries.Count,
Apprenticeships = GetLearningDeliveriesFundModelWithFAMCount(learningDeliveries, FundModelConstants.FM36),
Funded1619 = GetLearningDeliveriesFundModelWithFAMCount(learningDeliveries, FundModelConstants.FM25),
AdultSkilledFunded = GetLearningDeliveriesFundModelWithFAMCount(learningDeliveries, FundModelConstants.FM35),
CommunityLearningFunded = GetLearningDeliveriesFundModelWithFAMCount(learningDeliveries, FundModelConstants.FM10),
ESFFunded = GetLearningDeliveriesFundModelWithFAMCount(learningDeliveries, FundModelConstants.FM70),
OtherAdultFunded = GetLearningDeliveriesFundModelWithFAMCount(learningDeliveries, FundModelConstants.FM81),
Other1619Funded = GetLearningDeliveriesFundModelWithFAMCount(learningDeliveries, FundModelConstants.FM82),
NonFunded = GetLearningDeliveriesFundModelWithFAMCount(learningDeliveries, FundModelConstants.FM99),
AdvancedLoanLearningDeliveries = GetLearningDeliveriesFundModelWithFAMCount(learningDeliveries, FundModelConstants.FM99, LearningDeliveryFAMTypeConstants.ADL),
};
model.LearnerDestinationProgressionSummary = new LearnerDestinationProgressionSummary()
{
Total = looseLearnerDestinationAndProgressions.Count,
ValidLearnerDestinationProgressions = validLearnerDestinationAndProgressions.Count,
InValidLearnerDestinationProgressions = invalidLearnerDestinationAndProgressions.Count,
};
model.Errors = GetValidationErrorMessageModels(validationErrorsList, validationErrorMessageDictionary);
model.Warnings = GetValidationErrorMessageModels(validationErrorWarningsList, validationErrorMessageDictionary);
// Footer
model.ReportGeneratedAt = reportGeneratedAt;
model.ApplicationVersion = reportServiceContext.ServiceReleaseVersion;
model.OrganisationData = referenceDataRoot.MetaDatas.ReferenceDataVersions.OrganisationsVersion.Version;
model.LargeEmployerData = referenceDataRoot.MetaDatas.ReferenceDataVersions.Employers.Version;
model.LarsData = referenceDataRoot.MetaDatas.ReferenceDataVersions.LarsVersion.Version;
model.PostcodeData = referenceDataRoot.MetaDatas.ReferenceDataVersions.PostcodesVersion.Version;
model.FilePreparationDate = FormatFilePreparationDate(looseMessage?.HeaderEntity.CollectionDetailsEntity.FilePreparationDate);
model.CampusIdData = referenceDataRoot.MetaDatas.ReferenceDataVersions.CampusIdentifierVersion.Version;
model.DevolvedPostcodesData = referenceDataRoot.MetaDatas.ReferenceDataVersions.DevolvedPostcodesVersion?.Version;
return(model);
}
public List <ILR2021.DataStore.EF.ValidationError> BuildValidationErrors(IDataStoreContext dataStoreContext, IEnumerable <ValidationError> validationErrors, IEnumerable <ValidationRule> rules, ILooseMessage message)
{
return(validationErrors?
.Select(ve =>
{
var fieldValues = GetFieldValuesString(ve.ValidationErrorParameters);
var errorMessage = rules.FirstOrDefault(r =>
string.Equals(r.RuleName, ve.RuleName, StringComparison.OrdinalIgnoreCase))?.Message;
var learningDelivery =
message?
.Learners?
.FirstOrDefault(x => string.Equals(x.LearnRefNumber, ve.LearnerReferenceNumber, StringComparison.OrdinalIgnoreCase))?
.LearningDeliveries?
.FirstOrDefault(x => x.AimSeqNumberNullable == ve.AimSequenceNumber);
var severity = ve.Severity != null && ve.Severity.Length >= 1
? ve.Severity?.Substring(0, 1)
: null;
return new ILR2021.DataStore.EF.ValidationError
{
UKPRN = dataStoreContext.Ukprn,
SWSupAimID = learningDelivery?.SWSupAimId,
FileLevelError = 1,
AimSeqNum = ve.AimSequenceNumber,
ErrorMessage = errorMessage,
FieldValues = fieldValues,
LearnAimRef = learningDelivery?.LearnAimRef,
LearnRefNumber = ve.LearnerReferenceNumber,
RuleName = ve.RuleName,
Severity = severity,
Source = dataStoreContext.OriginalFilename
};
}).ToList() ?? new List <ILR2021.DataStore.EF.ValidationError>());
}
public void MapData(IDataStoreCache cache, IDataStoreContext dataStoreContext, IEnumerable <ValidationError> validationErrors, IEnumerable <ValidationRule> rules, ILooseMessage message)
{
cache.AddRange(BuildValidationErrors(dataStoreContext, validationErrors, rules, message));
}
public void MapValidationData(IDataStoreCache cache, IDataStoreContext dataStoreContext, ILooseMessage message, IEnumerable <ValidationError> validationErrors, IEnumerable <ValidationRule> rules) => _validationDataMapper.MapData(cache, dataStoreContext, validationErrors, rules, message);
public void MapInvalidLearnerData(IDataStoreCache cache, ILooseMessage message, IEnumerable <string> validLearnRefNumbers) => _invalidLearnerDataMapper.MapInvalidLearnerData(cache, message, validLearnRefNumbers);
public void MapData(IDataStoreCache cache, IDataStoreContext datStoreContext, IEnumerable <ValidationError> validationErrors, IEnumerable <ValidationRule> rules, ILooseMessage message)
{
}
