public void BuildHeaderData()
{
var reportServiceContextMock = new Mock <IReportServiceContext>();
reportServiceContextMock.Setup(r => r.IlrReportingFilename).Returns("10000000/ILR-2021-20190801-090000.xml");
reportServiceContextMock.Setup(r => r.Ukprn).Returns(1);
reportServiceContextMock.Setup(r => r.CollectionYear).Returns("2021");
var referenceDataRoot = new ReferenceDataRoot
{
Organisations = new List <Organisation>
{
new Organisation
{
UKPRN = 1,
Name = "OrgName"
}
}
};
var expectedDictionary = new Dictionary <string, string>
{
{ SummaryPageConstants.ProviderName, "OrgName" },
{ SummaryPageConstants.UKPRN, "1" },
{ SummaryPageConstants.ILRFile, "ILR-2021-20190801-090000.xml" },
{ SummaryPageConstants.Year, "2021" },
{ SummaryPageConstants.SecurityClassification, ReportingConstants.OfficialSensitive }
};
NewBuilder().BuildHeaderData(reportServiceContextMock.Object, referenceDataRoot).Should().BeEquivalentTo(expectedDictionary);
}
public IExternalDataCache PopulateAsync(ReferenceDataRoot referenceDataRoot, CancellationToken cancellationToken)
{
var referenceDataVersions = _metaDataMapperService.GetReferenceDataVersions(referenceDataRoot.MetaDatas);
return(new ExternalDataCache
{
LARSCurrentVersion = referenceDataVersions.LarsVersion.Version,
LARSLearningDelivery = _larsMapperService.MapLARSLearningDeliveries(referenceDataRoot.LARSLearningDeliveries),
LARSStandards = _larsMapperService.MapLARSStandards(referenceDataRoot.LARSStandards),
PostcodeRoots = _postcodesMapperService.MapPostcodes(referenceDataRoot.Postcodes),
PostcodeCurrentVersion = referenceDataVersions.PostcodesVersion.Version,
OrgVersion = referenceDataVersions.OrganisationsVersion.Version,
OrgFunding = _organisationsMapperService.MapOrgFundings(referenceDataRoot.Organisations),
CampusIdentifierSpecResources = _organisationsMapperService.MapCampusIdentifiers(referenceDataRoot.Organisations),
PostcodeSpecResources = _organisationsMapperService.MapPostcodeSpecialistResources(referenceDataRoot.Organisations),
LargeEmployers = _largeEmployersMapperService.MapLargeEmployers(referenceDataRoot.Employers),
FCSContractAllocations = _fcsMapperService.MapFCSContractAllocations(referenceDataRoot.FCSContractAllocations),
AECLatestInYearEarningHistory = _appsEarningsHistoryMapperService.MapAppsEarningsHistories(referenceDataRoot.AppsEarningsHistories),
Periods = _metaDataMapperService.BuildPeriods(referenceDataRoot.MetaDatas)
});
}
public async Task Provide()
{
var cancellationToken = CancellationToken.None;
var fileReference = "FileReference";
var container = "Container";
Stream stream = new MemoryStream();
var referenceDataRoot = new ReferenceDataRoot();
var fundingSrviceContextContextMock = new Mock <IFundingServiceContext>();
var fileServiceMock = new Mock <IFileService>();
var jsonSerializationServiceMock = new Mock <IJsonSerializationService>();
fundingSrviceContextContextMock.SetupGet(c => c.IlrReferenceDataKey).Returns(fileReference);
fundingSrviceContextContextMock.SetupGet(c => c.Container).Returns(container);
fileServiceMock.Setup(s => s.OpenReadStreamAsync(fileReference, container, cancellationToken)).Returns(Task.FromResult(stream)).Verifiable();
jsonSerializationServiceMock.Setup(s => s.Deserialize <ReferenceDataRoot>(stream)).Returns(referenceDataRoot).Verifiable();
var providedReferenceData = await NewProvider(fileServiceMock.Object, jsonSerializationServiceMock.Object).ProvideAsync(fundingSrviceContextContextMock.Object, cancellationToken);
providedReferenceData.Should().Be(referenceDataRoot);
fileServiceMock.VerifyAll();
jsonSerializationServiceMock.VerifyAll();
}
public async Task StoreAsync_WithCompression()
{
var cancellationToken = CancellationToken.None;
var outputReferenceDataFileKey = "FileReference";
var container = "Container";
ReferenceDataRoot referenceDataRoot = new ReferenceDataRoot();
Stream stream = new MemoryStream();
var referenceDataContextMock = new Mock <IReferenceDataContext>();
var fileServiceMock = new Mock <IFileService>();
var jsonSerializationServiceeMock = new Mock <IJsonSerializationService>();
referenceDataContextMock.SetupGet(c => c.OutputIlrReferenceDataFileKey).Returns(outputReferenceDataFileKey);
referenceDataContextMock.SetupGet(c => c.Container).Returns(container);
fileServiceMock.Setup(s => s.OpenWriteStreamAsync(referenceDataContextMock.Object.OutputIlrReferenceDataFileKey, referenceDataContextMock.Object.Container, cancellationToken)).Returns(Task.FromResult(stream)).Verifiable();
jsonSerializationServiceeMock.Setup(s => s.Serialize(referenceDataRoot, It.IsAny <GZipStream>())).Verifiable();
await NewProvider(jsonSerializationServiceeMock.Object, fileServiceMock.Object).StoreAsync(referenceDataContextMock.Object.OutputIlrReferenceDataFileKey, referenceDataContextMock.Object.Container, referenceDataRoot, true, cancellationToken);
fileServiceMock.VerifyAll();
jsonSerializationServiceeMock.VerifyAll();
}
public async Task Retrieve()
{
var cancellationToken = CancellationToken.None;
var referenceDataContextMock = new Mock <IReferenceDataContext>();
var messageProviderMock = new Mock <IMessageProvider>();
var referenceDataPopulationServiceMock = new Mock <IReferenceDataPopulationService>();
var filePersisterMock = new Mock <IFilePersister>();
var loggerMock = new Mock <ILogger>();
var edrsApiServiceMock = new Mock <IEdrsApiService>();
IMessage message = new TestMessage();
var referenceDataRoot = new ReferenceDataRoot();
var featureConfiguration = new FeatureConfiguration
{
EDRSAPIEnabled = "false"
};
messageProviderMock.Setup(p => p.ProvideAsync(referenceDataContextMock.Object, cancellationToken)).Returns(Task.FromResult(message)).Verifiable();
referenceDataPopulationServiceMock.Setup(s => s.PopulateAsync(referenceDataContextMock.Object, message, cancellationToken)).Returns(Task.FromResult(referenceDataRoot)).Verifiable();
filePersisterMock.Setup(s => s.StoreAsync(referenceDataContextMock.Object.OutputIlrReferenceDataFileKey, referenceDataContextMock.Object.Container, referenceDataRoot, false, cancellationToken)).Returns(Task.CompletedTask).Verifiable();
var service = NewService(messageProviderMock.Object, referenceDataPopulationServiceMock.Object, edrsApiServiceMock.Object, filePersisterMock.Object, loggerMock.Object, featureConfiguration);
await service.ExecuteAsync(referenceDataContextMock.Object, cancellationToken);
messageProviderMock.VerifyAll();
referenceDataPopulationServiceMock.VerifyAll();
filePersisterMock.VerifyAll();
}
public async Task ShouldPopulateDependentData()
{
var cancellationToken = CancellationToken.None;
var reportServiceMock = new Mock <IReportServiceContext>();
var indexMock = new Mock <IIndex <Type, IExternalDataProvider> >();
var message = new Message();
var referenceDataRoot = new ReferenceDataRoot();
var validationErrors = new List <ValidationErrors.Interface.Models.ValidationError>();
indexMock.Setup(x => x[typeof(IMessage)].ProvideAsync(reportServiceMock.Object, cancellationToken)).ReturnsAsync(message);
indexMock.Setup(x => x[typeof(ReferenceDataRoot)].ProvideAsync(reportServiceMock.Object, cancellationToken)).ReturnsAsync(referenceDataRoot);
indexMock.Setup(x => x[typeof(List <ValidationErrors.Interface.Models.ValidationError>)].ProvideAsync(reportServiceMock.Object, cancellationToken)).ReturnsAsync(validationErrors);
var service = new ReportsDependentDataPopulationService(indexMock.Object);
var dependsOnTypes = new List <Type>
{
typeof(IMessage),
typeof(ReferenceDataRoot),
typeof(List <ValidationErrors.Interface.Models.ValidationError>)
};
var result = await service.PopulateAsync(reportServiceMock.Object, dependsOnTypes, cancellationToken);
result.Get <IMessage>().Should().BeSameAs(message);
result.Get <ReferenceDataRoot>().Should().BeSameAs(referenceDataRoot);
result.Get <List <ValidationErrors.Interface.Models.ValidationError> >().Should().BeSameAs(validationErrors);
}
public void Populate(ReferenceDataRoot referenceDataRoot, IValidationContext validationContext)
{
var externalDataCache = (ExternalDataCache)_externalDataCache;
externalDataCache.Standards = _larsDataMapper.MapLarsStandards(referenceDataRoot.LARSStandards);
externalDataCache.StandardValidities = _larsDataMapper.MapLarsStandardValidities(referenceDataRoot.LARSStandards);
externalDataCache.LearningDeliveries = _larsDataMapper.MapLarsLearningDeliveries(referenceDataRoot.LARSLearningDeliveries);
externalDataCache.ULNs = _ulnDataMapper.MapUlns(referenceDataRoot.ULNs);
externalDataCache.Postcodes = _postcodesDataMapper.MapPostcodes(referenceDataRoot.Postcodes);
externalDataCache.ONSPostcodes = _postcodesDataMapper.MapONSPostcodes(referenceDataRoot.Postcodes);
externalDataCache.DevolvedPostcodes = _postcodesDataMapper.MapDevolvedPostcodes(referenceDataRoot.DevolvedPostcodes?.Postcodes);
externalDataCache.Organisations = _organisationsDataMapper.MapOrganisations(referenceDataRoot.Organisations);
externalDataCache.CampusIdentifiers = _organisationsDataMapper.MapCampusIdentifiers(referenceDataRoot.Organisations);
externalDataCache.EPAOrganisations = _epaOrgDataMapper.MapEpaOrganisations(referenceDataRoot.EPAOrganisations);
externalDataCache.FCSContractAllocations = _fcsDataMapper.MapFcsContractAllocations(referenceDataRoot.FCSContractAllocations);
externalDataCache.ERNs = _employersDataMapper.MapEmployers(referenceDataRoot.Employers);
externalDataCache.ValidationErrors = _validationErrorsDataMapper.MapValidationErrors(referenceDataRoot.MetaDatas?.ValidationErrors);
externalDataCache.ValidationRules = _validationRulesDataMapper.MapValidationRules(referenceDataRoot.MetaDatas?.ValidationRules);
externalDataCache.ReturnPeriod = validationContext.ReturnPeriod;
}
public void Populate(IValidationContext validationContext, IMessage message, ReferenceDataRoot referenceDataRoot, LearnerReferenceData learnerReferenceData)
{
_messageCachePopulationService.Populate(message);
_internalDataCachePopulationService.Populate(referenceDataRoot);
_fileDataCachePopulationService.Populate(validationContext, message);
_externalDataCachePopulationService.Populate(referenceDataRoot, validationContext);
_learnerReferenceDataCachePopulationService.Populate(learnerReferenceData);
}
public async Task GenerateAsync()
{
var container = "container";
var reportServiceContext = new Mock <IReportServiceContext>();
reportServiceContext.SetupGet(c => c.Container).Returns(container);
var cancellationToken = CancellationToken.None;
var message = Mock.Of <ILooseMessage>();
var validationErrorsMetadata = new List <ESFA.DC.ILR.ReportService.Models.ReferenceData.MetaData.ValidationError>();
var referenceDataRoot = new ReferenceDataRoot()
{
MetaDatas = new MetaData()
{
ValidationErrors = validationErrorsMetadata
}
};
var validationErrors = Mock.Of <List <ValidationError> >();
var dependentData = new Mock <IReportServiceDependentData>();
dependentData.Setup(d => d.Get <ILooseMessage>()).Returns(message);
dependentData.Setup(d => d.Get <ReferenceDataRoot>()).Returns(referenceDataRoot);
dependentData.Setup(d => d.Get <List <ValidationError> >()).Returns(validationErrors);
var fileName = "FileName";
var fileNameServiceMock = new Mock <IFileNameService>();
fileNameServiceMock.Setup(s => s.GetFilename(reportServiceContext.Object, "Rule Violation Report", OutputTypes.Csv, true)).Returns(fileName);
var validationErrorBuilder = new Mock <IValidationErrorsReportBuilder>();
var validationErrorRows = Mock.Of <IEnumerable <ValidationErrorRow> >();
validationErrorBuilder.Setup(b => b.Build(validationErrors, message, validationErrorsMetadata)).Returns(validationErrorRows);
var csvServiceMock = new Mock <ICsvFileService>();
var frontEndValidationReportMock = new Mock <IFrontEndValidationReport>();
var report = NewReport(validationErrorBuilder.Object, csvServiceMock.Object, frontEndValidationReportMock.Object, fileNameServiceMock.Object);
var result = await report.GenerateAsync(reportServiceContext.Object, dependentData.Object, cancellationToken);
result.Should().HaveCount(1);
result.First().Should().Be(fileName);
frontEndValidationReportMock.Verify(r => r.GenerateAsync(reportServiceContext.Object, validationErrorRows, false, cancellationToken));
csvServiceMock.Verify(s => s.WriteAsync <ValidationErrorRow, ValidationErrorMapper>(validationErrorRows, fileName, container, cancellationToken, null, null));
}
public void BuildFooterData()
{
var date = new DateTime(2019, 8, 1);
var dateTimeProviderMock = new Mock <IDateTimeProvider>();
dateTimeProviderMock.Setup(d => d.GetNowUtc()).Returns(date);
dateTimeProviderMock.Setup(d => d.ConvertUtcToUk(It.IsAny <DateTime>())).Returns(date);
var reportServiceContextMock = new Mock <IReportServiceContext>();
IMessage message = new TestMessage
{
HeaderEntity = new TestHeader
{
CollectionDetailsEntity = new TestCollectionDetails
{
FilePreparationDate = new DateTime(2019, 8, 1)
}
}
};
var referenceDataRoot = new ReferenceDataRoot
{
MetaDatas = new MetaData
{
ReferenceDataVersions = new ReferenceDataVersion
{
OrganisationsVersion = new OrganisationsVersion {
Version = "1"
},
PostcodesVersion = new PostcodesVersion {
Version = "1"
},
Employers = new EmployersVersion {
Version = "1"
},
LarsVersion = new LarsVersion {
Version = "1"
}
}
}
};
var expectedDictionary = new Dictionary <string, string>
{
{ SummaryPageConstants.FilePreparationDate, "01/08/2019" },
{ SummaryPageConstants.LARSVersion, "1" },
{ SummaryPageConstants.PostcodeVersion, "1" },
{ SummaryPageConstants.OrganisationVersion, "1" },
{ SummaryPageConstants.LargeEmployersVersion, "1" },
{ SummaryPageConstants.ReportGeneratedAt, "00:00:00 on 01/08/2019" },
};
NewBuilder(dateTimeProviderMock.Object).BuildFooterData(reportServiceContextMock.Object, message, referenceDataRoot).Should().BeEquivalentTo(expectedDictionary);
}
public void Populate()
{
var validationContextMock = new Mock <IValidationContext>();
var externalDataCache = new ExternalDataCache();
var employersDataMapperMock = new Mock <IEmployersDataMapper>();
var epaOrgDataMapperMock = new Mock <IEpaOrgDataMapper>();
var fcsDataMapperMock = new Mock <IFcsDataMapper>();
var larsDataMapperMock = new Mock <ILarsDataMapper>();
var organisationsDataMapperMock = new Mock <IOrganisationsDataMapper>();
var postcodesDataMapperMock = new Mock <IPostcodesDataMapper>();
var ulnDataMapperMock = new Mock <IUlnDataMapper>();
var validationErrorsDataMapperMock = new Mock <IValidationErrorsDataMapper>();
var validationRulesDataMapperMock = new Mock <IValidationRulesDataMapper>();
var referenceDataRoot = new ReferenceDataRoot();
employersDataMapperMock.Setup(m => m.MapEmployers(It.IsAny <List <ReferenceDataService.Model.Employers.Employer> >())).Returns(new List <int>()).Verifiable();
epaOrgDataMapperMock.Setup(m => m.MapEpaOrganisations(It.IsAny <List <ReferenceDataService.Model.EPAOrganisations.EPAOrganisation> >())).Returns(new Dictionary <string, List <EPAOrganisations> >()).Verifiable();
fcsDataMapperMock.Setup(m => m.MapFcsContractAllocations(It.IsAny <List <ReferenceDataService.Model.FCS.FcsContractAllocation> >())).Returns(new Dictionary <string, IFcsContractAllocation>()).Verifiable();
larsDataMapperMock.Setup(m => m.MapLarsLearningDeliveries(It.IsAny <List <ReferenceDataService.Model.LARS.LARSLearningDelivery> >())).Returns(new Dictionary <string, LearningDelivery>()).Verifiable();
larsDataMapperMock.Setup(m => m.MapLarsStandards(It.IsAny <List <ReferenceDataService.Model.LARS.LARSStandard> >())).Returns(new List <ILARSStandard>()).Verifiable();
larsDataMapperMock.Setup(m => m.MapLarsStandardValidities(It.IsAny <List <ReferenceDataService.Model.LARS.LARSStandard> >())).Returns(new List <ILARSStandardValidity>()).Verifiable();
organisationsDataMapperMock.Setup(m => m.MapOrganisations(It.IsAny <List <ReferenceDataService.Model.Organisations.Organisation> >())).Returns(new Dictionary <long, Organisation>()).Verifiable();
organisationsDataMapperMock.Setup(m => m.MapCampusIdentifiers(It.IsAny <List <ReferenceDataService.Model.Organisations.Organisation> >())).Returns(new List <ICampusIdentifier>()).Verifiable();
postcodesDataMapperMock.Setup(m => m.MapONSPostcodes(It.IsAny <List <ReferenceDataService.Model.Postcodes.Postcode> >())).Returns(new List <ONSPostcode>()).Verifiable();
postcodesDataMapperMock.Setup(m => m.MapPostcodes(It.IsAny <List <ReferenceDataService.Model.Postcodes.Postcode> >())).Returns(new List <string>()).Verifiable();
postcodesDataMapperMock.Setup(m => m.MapDevolvedPostcodes(It.IsAny <List <ReferenceDataService.Model.PostcodesDevolution.DevolvedPostcode> >())).Returns(new Dictionary <string, IReadOnlyCollection <IDevolvedPostcode> >()).Verifiable();
ulnDataMapperMock.Setup(m => m.MapUlns(It.IsAny <List <long> >())).Returns(new List <long>()).Verifiable();
validationErrorsDataMapperMock.Setup(m => m.MapValidationErrors(It.IsAny <List <ReferenceDataService.Model.MetaData.ValidationError> >())).Returns(new Dictionary <string, ValidationError>()).Verifiable();
validationRulesDataMapperMock.Setup(m => m.MapValidationRules(It.IsAny <List <ReferenceDataService.Model.MetaData.ValidationRule> >())).Returns(new List <ValidationRule>()).Verifiable();
NewService(
externalDataCache,
employersDataMapperMock.Object,
epaOrgDataMapperMock.Object,
fcsDataMapperMock.Object,
larsDataMapperMock.Object,
organisationsDataMapperMock.Object,
postcodesDataMapperMock.Object,
ulnDataMapperMock.Object,
validationErrorsDataMapperMock.Object,
validationRulesDataMapperMock.Object).Populate(referenceDataRoot, validationContextMock.Object);
employersDataMapperMock.VerifyAll();
epaOrgDataMapperMock.VerifyAll();
fcsDataMapperMock.VerifyAll();
larsDataMapperMock.VerifyAll();
organisationsDataMapperMock.VerifyAll();
postcodesDataMapperMock.VerifyAll();
ulnDataMapperMock.VerifyAll();
validationErrorsDataMapperMock.VerifyAll();
validationRulesDataMapperMock.VerifyAll();
}
public void Populate(ReferenceDataRoot referenceDataRoot)
{
var internalDataCache = (InternalDataCache)_internalDataCache;
var lookupsDictionary = _lookupsDataMapper.BuildLookups(referenceDataRoot.MetaDatas.Lookups);
var academicYear = BuildAcademicYear();
internalDataCache.AcademicYear = _lookupsDataMapper.MapAcademicYear(academicYear);
internalDataCache.IntegerLookups = _lookupsDataMapper.MapIntegerLookups(lookupsDictionary);
internalDataCache.LimitedLifeLookups = _lookupsDataMapper.MapLimitedLifeLookups(lookupsDictionary);
internalDataCache.ListItemLookups = _lookupsDataMapper.MapListItemLookups(lookupsDictionary);
internalDataCache.StringLookups = _lookupsDataMapper.MapStringLookups(lookupsDictionary);
}
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 void Build()
{
var referenceDataRoot = new ReferenceDataRoot()
{
Organisations = new List <Organisation>()
{
new Organisation()
{
UKPRN = 987654321,
Name = "Provider XYZ",
}
}
};
var message = new TestMessage()
{
HeaderEntity = new TestHeader()
{
SourceEntity = new TestSource()
{
ProtectiveMarkingString = "OFFICIAL-SENSITIVE-Personal"
}
}
};
var dependentDataMock = new Mock <IReportServiceDependentData>();
dependentDataMock.Setup(d => d.Get <IMessage>()).Returns(message);
dependentDataMock.Setup(d => d.Get <ReferenceDataRoot>()).Returns(referenceDataRoot);
var reportServiceContextMock = new Mock <IReportServiceContext>();
reportServiceContextMock.SetupGet(c => c.Ukprn).Returns(987654321);
reportServiceContextMock.SetupGet(c => c.LastIlrFileUpdate).Returns("01/01/2020 12:00");
reportServiceContextMock.SetupGet(c => c.OriginalFilename).Returns("ILR-12345678-1920-20191005-151322-01.xml");
var sut = NewBuilder().Build(reportServiceContextMock.Object, dependentDataMock.Object);
sut.HeaderData.Should().NotBeNull();
sut.HeaderData.Count.Should().Be(5);
sut.HeaderData.GetValueOrDefault("Provider Name:").Should().Be("Provider XYZ");
sut.HeaderData.GetValueOrDefault("UKPRN:").Should().Be("987654321");
sut.HeaderData.GetValueOrDefault("ILR File:").Should().Be("ILR-12345678-1920-20191005-151322-01.xml");
sut.HeaderData.GetValueOrDefault("Last ILR File Update:").Should().Be("01/01/2020 12:00");
sut.HeaderData.GetValueOrDefault("Security Classification").Should().Be("OFFICIAL-SENSITIVE-Personal");
}
public async void PopulateAsync()
{
IMessage message = new TestMessage();
var mapperData = new MapperData();
var desktopReferenceData = new ReferenceDataRoot();
var metaData = new MetaData();
var referenceDataContext = new Mock <IReferenceDataContext>();
var messageMapperServiceMock = new Mock <IMessageMapperService>();
var desktopReferenceDataMapperServiceMock = new Mock <IDesktopReferenceDataMapperService>();
messageMapperServiceMock.Setup(sm => sm.MapFromMessage(message)).Returns(mapperData);
desktopReferenceDataMapperServiceMock.Setup(sm => sm.MapReferenceData(referenceDataContext.Object, It.IsAny <MapperData>(), CancellationToken.None)).Returns(Task.FromResult(desktopReferenceData));
var result = await NewService(messageMapperServiceMock.Object, desktopReferenceDataMapperServiceMock.Object).PopulateAsync(referenceDataContext.Object, message, CancellationToken.None);
result.Should().BeEquivalentTo(desktopReferenceData);
}
public async Task MutateAsync()
{
var cancellationToken = CancellationToken.None;
var easUploadTime = new DateTime(2020, 8, 1, 9, 0, 0);
var refDataModel = new ReferenceDataRoot
{
MetaDatas = new MetaData
{
ReferenceDataVersions = new ReferenceDataVersion
{
EasFileDetails = new EasFileDetails
{
FileName = "1/EAS-1-2.csv",
UploadDateTime = easUploadTime
}
}
}
};
var reportServiceDependentData = new Mock <IReportServiceDependentData>(MockBehavior.Strict);
reportServiceDependentData.Setup(x => x.Get <ReferenceDataRoot>()).Returns(refDataModel);
reportServiceDependentData.Setup(x => x.Contains <ReferenceDataRoot>()).Returns(true);
IReportServiceContext contextIn = new ReportServiceJobContextMessageContextStub(1, "1/ILR-1-2.xml", "1/ILR-1-2.xml", new DateTime(2020, 8, 2, 9, 0, 0));
var dateTimeProviderMock = new Mock <IDateTimeProvider>();
dateTimeProviderMock.Setup(x => x.ConvertUtcToUk(contextIn.SubmissionDateTimeUtc)).Returns(new DateTime(2020, 8, 2, 8, 0, 0));
dateTimeProviderMock.Setup(x => x.ConvertUtcToUk(easUploadTime)).Returns(new DateTime(2020, 8, 1, 8, 0, 0));
var mutator = new ReportServiceContextKeysMutator(dateTimeProviderMock.Object);
var contextOut = await mutator.MutateAsync(contextIn, reportServiceDependentData.Object, cancellationToken);
contextOut.IlrReportingFilename.Should().Be("ILR-1-2.xml");
contextOut.EasReportingFilename.Should().Be("EAS-1-2.csv");
contextOut.LastIlrFileUpdate.Should().Be("02/08/2020 08:00:00");
contextOut.LastEasFileUpdate.Should().Be("01/08/2020 08:00:00");
}
public void Build_NoData()
{
var referenceData = new ReferenceDataRoot
{
Organisations = new List <Organisation>
{
new Organisation
{
UKPRN = 1,
Name = "OrgName1",
},
new Organisation
{
UKPRN = 2,
Name = "OrgName2",
}
},
LARSLearningDeliveries = new List <LARSLearningDelivery>
{
new LARSLearningDelivery
{
LearnAimRef = "LearnAImRef1",
LearnAimRefTypeDesc = "LeanAimRef1Desc"
}
}
};
var frmData = new FrmReferenceData();
var message = new TestMessage();
var context = new Mock <IReportServiceContext>();
context.Setup(x => x.ReturnPeriodName).Returns("R01");
var refData = new Mock <IReportServiceDependentData>();
refData.Setup(x => x.Get <FrmReferenceData>()).Returns(frmData);
refData.Setup(x => x.Get <IMessage>()).Returns(message);
refData.Setup(x => x.Get <ReferenceDataRoot>()).Returns(referenceData);
NewBuilder().Build(context.Object, refData.Object).Should().BeNullOrEmpty();
}
public async Task ExecuteAsync()
{
IMessage message = new TestMessage();
var referenceData = new ReferenceDataRoot();
IExternalDataCache externalDataCache = new ExternalDataCache();
var externalData = "ExtermalData";
var cancellationToken = CancellationToken.None;
var fundingServiceContextMock = new Mock <IFundingServiceContext>();
var jsonSerializationServiceMock = new Mock <IJsonSerializationService>();
var ilrFileProviderServiceMock = new Mock <IFileProviderService <IMessage> >();
var ilrReferenceDataProviderServiceMock = new Mock <IFileProviderService <ReferenceDataRoot> >();
var externalCachePopulationServiceMock = new Mock <IExternalDataCachePopulationService>();
var fundingTaskProviderMock = new Mock <IFundingTaskProvider>();
var loggerMock = new Mock <ILogger>();
ilrFileProviderServiceMock.Setup(sm => sm.ProvideAsync(fundingServiceContextMock.Object, cancellationToken)).Returns(Task.FromResult(message)).Verifiable();
ilrReferenceDataProviderServiceMock.Setup(sm => sm.ProvideAsync(fundingServiceContextMock.Object, cancellationToken)).Returns(Task.FromResult(referenceData)).Verifiable();
externalCachePopulationServiceMock.Setup(sm => sm.PopulateAsync(referenceData, cancellationToken)).Returns(externalDataCache).Verifiable();
jsonSerializationServiceMock.Setup(sm => sm.Serialize(externalDataCache)).Returns(externalData).Verifiable();
fundingTaskProviderMock.Setup(sm => sm.ProvideAsync(fundingServiceContextMock.Object, message, externalData, cancellationToken)).Returns(Task.FromResult(true)).Verifiable();
await NewService(
jsonSerializationServiceMock.Object,
ilrFileProviderServiceMock.Object,
ilrReferenceDataProviderServiceMock.Object,
externalCachePopulationServiceMock.Object,
fundingTaskProviderMock.Object,
loggerMock.Object).ExecuteAsync(fundingServiceContextMock.Object, cancellationToken);
jsonSerializationServiceMock.VerifyAll();
ilrFileProviderServiceMock.VerifyAll();
ilrReferenceDataProviderServiceMock.VerifyAll();
externalCachePopulationServiceMock.VerifyAll();
fundingTaskProviderMock.VerifyAll();
}
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 IDictionary <int, LARSStandard> BuildLarsStandardDictionary(ReferenceDataRoot referenceDataRoot)
{
return(referenceDataRoot?.LARSStandards?.ToDictionary(ld => ld.StandardCode, ld => ld) ?? new Dictionary <int, LARSStandard>());
}
public IDictionary <string, LARSLearningDelivery> BuildLarsLearningDeliveryDictionary(ReferenceDataRoot referenceDataRoot)
{
return(referenceDataRoot?.LARSLearningDeliveries?.ToDictionary(ld => ld.LearnAimRef, ld => ld, StringComparer.OrdinalIgnoreCase) ?? new Dictionary <string, LARSLearningDelivery>());
}
public void BuildHandlesMissingLearningDeliveryProviderSpecDeliveryMonitorings()
{
// Arrange
var message = new Message
{
Learner = new MessageLearner[]
{
new MessageLearner
{
LearningDelivery = new MessageLearnerLearningDelivery[]
{
new MessageLearnerLearningDelivery
{
CompStatus = 4,
AimSeqNumber = 2,
LearnAimRef = "aimref",
FundModel = 36,
LearningDeliveryFAM = new MessageLearnerLearningDeliveryLearningDeliveryFAM[]
{
new MessageLearnerLearningDeliveryLearningDeliveryFAM
{
LearnDelFAMType = "RES"
}
},
LearnActEndDate = new DateTime(2018, 1, 1),
LearnActEndDateSpecified = true
},
}
}
}
};
var referenceDataRoot = new ReferenceDataRoot
{
Organisations = new List <Organisation> {
new Organisation {
Name = "org", UKPRN = 123
}
},
MetaDatas = new MetaData {
CollectionDates = new IlrCollectionDates {
ReturnPeriods = new HashSet <ReturnPeriod> {
new ReturnPeriod {
Start = new DateTime(2020, 01, 01), End = new DateTime(2020, 01, 01)
}
}
}
},
LARSLearningDeliveries = new HashSet <LARSLearningDelivery>
{
new LARSLearningDelivery
{
LearnAimRef = "aimref",
LARSLearningDeliveryCategories = new HashSet <LARSLearningDeliveryCategory>
{
new LARSLearningDeliveryCategory
{
CategoryRef = 123
}
},
}
}
};
var reportServiceContext = new Mock <IReportServiceContext>();
reportServiceContext.Setup(s => s.ReturnPeriod).Returns(10);
reportServiceContext.Setup(s => s.Ukprn).Returns(123);
reportServiceContext.Setup(s => s.SubmissionDateTimeUtc).Returns(new DateTime(2020, 01, 01));
var reportServiceDependentData = new Mock <IReportServiceDependentData>();
reportServiceDependentData.Setup(s => s.Get <IMessage>()).Returns(message);
reportServiceDependentData.Setup(s => s.Get <ReferenceDataRoot>()).Returns(referenceDataRoot);
var sit = new Frm15ReportModelBuilder();
// Act
var result = sit.Build(reportServiceContext.Object, reportServiceDependentData.Object);
// Assert
result.Should().NotBeNull();
}
public IDictionary <string, string> BuildHeaderData(IReportServiceContext reportServiceContext, ReferenceDataRoot referenceDataRoot)
{
var organisationName = referenceDataRoot.Organisations?.FirstOrDefault(o => o.UKPRN == reportServiceContext.Ukprn)?.Name;
var fileName = ExtractFileName(reportServiceContext.IlrReportingFilename);
return(new Dictionary <string, string>()
{
{ SummaryPageConstants.ProviderName, organisationName },
{ SummaryPageConstants.UKPRN, reportServiceContext.Ukprn.ToString() },
{ SummaryPageConstants.ILRFile, fileName },
{ SummaryPageConstants.Year, reportServiceContext.CollectionYear },
{ SummaryPageConstants.SecurityClassification, ReportingConstants.OfficialSensitive }
});
}
public void Build()
{
var dependentDataMock = new Mock <IReportServiceDependentData>();
var learningDeliveryFam = new Mock <ILearningDeliveryFAM>();
learningDeliveryFam.SetupGet(fam => fam.LearnDelFAMType).Returns("SOF");
learningDeliveryFam.SetupGet(fam => fam.LearnDelFAMCode).Returns("107");
var albLearningDeliveryFam = new Mock <ILearningDeliveryFAM>();
albLearningDeliveryFam.SetupGet(fam => fam.LearnDelFAMType).Returns("ALB");
var learningDeliveryFams = new List <ILearningDeliveryFAM>()
{
learningDeliveryFam.Object,
albLearningDeliveryFam.Object
};
var learningDelivery = new TestLearningDelivery()
{
FundModel = 25,
LearnAimRef = "learnAimRef",
AimSeqNumber = 1,
LearningDeliveryFAMs = learningDeliveryFams,
StdCodeNullable = 1
};
var message = new TestMessage()
{
Learners = BuildLearners(learningDelivery),
HeaderEntity = new TestHeader()
{
CollectionDetailsEntity = new MessageHeaderCollectionDetails()
{
FilePreparationDate = new DateTime(2019, 11, 06)
}
}
};
var referenceDataRoot = new ReferenceDataRoot()
{
Organisations = new List <Organisation>()
{
new Organisation()
{
UKPRN = 987654321,
Name = "Provider XYZ"
}
},
MetaDatas = new MetaData()
{
ReferenceDataVersions = new ReferenceDataVersion()
{
OrganisationsVersion = new OrganisationsVersion {
Version = "1.1.1.1"
},
Employers = new EmployersVersion {
Version = "2.2.2.2"
},
LarsVersion = new LarsVersion {
Version = "3.3.3.3"
},
PostcodesVersion = new PostcodesVersion {
Version = "4.4.4.4"
}
}
}
};
var fm25Global = new FM25Global()
{
Learners = BuildFm25Learners()
};
dependentDataMock.Setup(d => d.Get <IMessage>()).Returns(message);
dependentDataMock.Setup(d => d.Get <ReferenceDataRoot>()).Returns(referenceDataRoot);
dependentDataMock.Setup(d => d.Get <FM25Global>()).Returns(fm25Global);
var submissionDateTime = new DateTime(2019, 1, 1, 1, 1, 1);
var ukDateTime = new DateTime(2020, 1, 1, 1, 1, 1);
var dateTimeProvider = new Mock <IDateTimeProvider>();
var reportServiceContextMock = new Mock <IReportServiceContext>();
reportServiceContextMock.SetupGet(c => c.Ukprn).Returns(987654321);
reportServiceContextMock.SetupGet(c => c.SubmissionDateTimeUtc).Returns(submissionDateTime);
reportServiceContextMock.SetupGet(c => c.ServiceReleaseVersion).Returns("11.22.3300.4321");
reportServiceContextMock.SetupGet(c => c.IlrReportingFilename).Returns("ILR-12345678-1920-20191005-151322-01.xml");
dateTimeProvider.Setup(p => p.ConvertUtcToUk(submissionDateTime)).Returns(ukDateTime);
dateTimeProvider.Setup(p => p.GetNowUtc()).Returns(submissionDateTime);
var result = NewBuilder(dateTimeProvider.Object).Build(reportServiceContextMock.Object, dependentDataMock.Object);
result.ApplicationVersion.Should().Be("11.22.3300.4321");
result.ComponentSetVersion.Should().Be("NA");
result.FilePreparationDate.Should().Be("06/11/2019");
result.IlrFile.Should().Be("ILR-12345678-1920-20191005-151322-01.xml");
result.LargeEmployerData.Should().Be("2.2.2.2");
result.LarsData.Should().Be("3.3.3.3");
result.OrganisationData.Should().Be("1.1.1.1");
result.PostcodeData.Should().Be("4.4.4.4");
result.ProviderName.Should().Be("Provider XYZ");
result.ReportGeneratedAt.Should().Be("Report generated at: 01:01:01 on 01/01/2020");
result.StudyProgramme.DirectFunded1416StudentsTotal.WithEHCP.Should().Be(1);
result.StudyProgramme.DirectFunded1416StudentsTotal.WithoutEHCP.Should().Be(0);
result.StudyProgramme.DirectFunded1416StudentsTotal.HNSWithoutEHCP.Should().Be(0);
result.StudyProgramme.DirectFunded1416StudentsTotal.EHCPWithHNS.Should().Be(1);
result.StudyProgramme.DirectFunded1416StudentsTotal.EHCPWithoutHNS.Should().Be(0);
result.StudyProgramme.DirectFunded1416StudentsTotal.TotalFundineStudents.Should().Be(1);
result.StudyProgramme.IncludingHNS1619StudentsTotal.WithEHCP.Should().Be(2);
result.StudyProgramme.IncludingHNS1619StudentsTotal.WithoutEHCP.Should().Be(0);
result.StudyProgramme.IncludingHNS1619StudentsTotal.HNSWithoutEHCP.Should().Be(0);
result.StudyProgramme.IncludingHNS1619StudentsTotal.EHCPWithHNS.Should().Be(1);
result.StudyProgramme.IncludingHNS1619StudentsTotal.EHCPWithoutHNS.Should().Be(1);
result.StudyProgramme.IncludingHNS1619StudentsTotal.TotalFundineStudents.Should().Be(2);
result.StudyProgramme.EHCP1924StudentsTotal.WithEHCP.Should().Be(0);
result.StudyProgramme.EHCP1924StudentsTotal.WithoutEHCP.Should().Be(0);
result.StudyProgramme.EHCP1924StudentsTotal.HNSWithoutEHCP.Should().Be(0);
result.StudyProgramme.EHCP1924StudentsTotal.EHCPWithHNS.Should().Be(0);
result.StudyProgramme.EHCP1924StudentsTotal.EHCPWithoutHNS.Should().Be(0);
result.StudyProgramme.EHCP1924StudentsTotal.TotalFundineStudents.Should().Be(0);
result.StudyProgramme.Continuing19PlusExcludingEHCPStudentsTotal.WithEHCP.Should().Be(0);
result.StudyProgramme.Continuing19PlusExcludingEHCPStudentsTotal.WithoutEHCP.Should().Be(0);
result.StudyProgramme.Continuing19PlusExcludingEHCPStudentsTotal.HNSWithoutEHCP.Should().Be(0);
result.StudyProgramme.Continuing19PlusExcludingEHCPStudentsTotal.EHCPWithHNS.Should().Be(0);
result.StudyProgramme.Continuing19PlusExcludingEHCPStudentsTotal.EHCPWithoutHNS.Should().Be(0);
result.StudyProgramme.Continuing19PlusExcludingEHCPStudentsTotal.TotalFundineStudents.Should().Be(0);
result.TLevel.DirectFunded1416StudentsTotal.WithEHCP.Should().Be(1);
result.TLevel.DirectFunded1416StudentsTotal.WithoutEHCP.Should().Be(0);
result.TLevel.DirectFunded1416StudentsTotal.HNSWithoutEHCP.Should().Be(0);
result.TLevel.DirectFunded1416StudentsTotal.EHCPWithHNS.Should().Be(0);
result.TLevel.DirectFunded1416StudentsTotal.EHCPWithoutHNS.Should().Be(1);
result.TLevel.DirectFunded1416StudentsTotal.TotalFundineStudents.Should().Be(1);
result.TLevel.IncludingHNS1619StudentsTotal.WithEHCP.Should().Be(0);
result.TLevel.IncludingHNS1619StudentsTotal.WithoutEHCP.Should().Be(0);
result.TLevel.IncludingHNS1619StudentsTotal.HNSWithoutEHCP.Should().Be(0);
result.TLevel.IncludingHNS1619StudentsTotal.EHCPWithHNS.Should().Be(0);
result.TLevel.IncludingHNS1619StudentsTotal.EHCPWithoutHNS.Should().Be(0);
result.TLevel.IncludingHNS1619StudentsTotal.TotalFundineStudents.Should().Be(0);
result.TLevel.EHCP1924StudentsTotal.WithEHCP.Should().Be(2);
result.TLevel.EHCP1924StudentsTotal.WithoutEHCP.Should().Be(0);
result.TLevel.EHCP1924StudentsTotal.HNSWithoutEHCP.Should().Be(0);
result.TLevel.EHCP1924StudentsTotal.EHCPWithHNS.Should().Be(1);
result.TLevel.EHCP1924StudentsTotal.EHCPWithoutHNS.Should().Be(1);
result.TLevel.EHCP1924StudentsTotal.TotalFundineStudents.Should().Be(2);
result.TLevel.Continuing19PlusExcludingEHCPStudentsTotal.WithEHCP.Should().Be(2);
result.TLevel.Continuing19PlusExcludingEHCPStudentsTotal.WithoutEHCP.Should().Be(0);
result.TLevel.Continuing19PlusExcludingEHCPStudentsTotal.HNSWithoutEHCP.Should().Be(0);
result.TLevel.Continuing19PlusExcludingEHCPStudentsTotal.EHCPWithHNS.Should().Be(1);
result.TLevel.Continuing19PlusExcludingEHCPStudentsTotal.EHCPWithoutHNS.Should().Be(1);
result.TLevel.Continuing19PlusExcludingEHCPStudentsTotal.TotalFundineStudents.Should().Be(2);
result.Ukprn.Should().Be("987654321");
result.Year.Should().Be("2020/21");
}
public async Task SystemTest()
{
var container = "Output";
var ukprn = 123456789;
var reportGeneratedAt = new DateTime(2019, 03, 03);
var refDataRoot = new ReferenceDataRoot()
{
Organisations = new List <Organisation>()
{
new Organisation()
{
UKPRN = ukprn,
Name = "OrganisationName"
}
},
MetaDatas = new MetaData()
{
ReferenceDataVersions = new ReferenceDataVersion()
{
OrganisationsVersion = new OrganisationsVersion {
Version = "orgVersion"
},
EasFileDetails = new EasFileDetails {
UploadDateTime = new DateTime(2019, 01, 01)
},
LarsVersion = new LarsVersion {
Version = "larsVersion"
},
PostcodesVersion = new PostcodesVersion {
Version = "postcodeVersion"
},
Employers = new EmployersVersion {
Version = "employersVersion"
}
}
}
};
var message = new Message()
{
Header = new MessageHeader()
{
CollectionDetails = new MessageHeaderCollectionDetails()
{
FilePreparationDate = new DateTime(2019, 01, 02)
}
}
};
var reportServiceDependentDataMock = new Mock <IReportServiceDependentData>();
reportServiceDependentDataMock.Setup(x => x.Get <ReferenceDataRoot>()).Returns(refDataRoot);
reportServiceDependentDataMock.Setup(x => x.Get <IMessage>()).Returns(message);
var periodisedValuesLookupProvider = new Mock <IPeriodisedValuesLookupProvider>();
periodisedValuesLookupProvider.Setup(p => p.Provide(It.IsAny <IEnumerable <FundingDataSources> >(), reportServiceDependentDataMock.Object)).Returns(new PeriodisedValuesLookup());
var dateTimeProviderMock = new Mock <IDateTimeProvider>();
dateTimeProviderMock.Setup(x => x.GetNowUtc()).Returns(reportGeneratedAt);
dateTimeProviderMock.Setup(x => x.ConvertUtcToUk(reportGeneratedAt)).Returns(reportGeneratedAt);
var fundingSummaryReportModelBuilder = new DesktopFundingSummaryReportModelBuilder(periodisedValuesLookupProvider.Object, dateTimeProviderMock.Object);
var reportServiceContextMock = new Mock <IReportServiceContext>();
reportServiceContextMock.Setup(c => c.Container).Returns(container);
reportServiceContextMock.Setup(c => c.Ukprn).Returns(ukprn);
reportServiceContextMock.Setup(c => c.IlrReportingFilename).Returns("ILR-11111111-1920-20190507-152000-01");
reportServiceContextMock.Setup(c => c.ServiceReleaseVersion).Returns("ServiceReleaseVersion");
var workBook = new Workbook();
workBook.Worksheets.Add("FundingSummaryReport");
var excelService = new Mock <IExcelFileService>();
excelService.Setup(es => es.NewWorkbook()).Returns(workBook);
excelService.Setup(es => es.GetWorksheetFromWorkbook(workBook, "FundingSummaryReport")).Returns(workBook.Worksheets["FundingSummaryReport"]);
var fileNameServiceMock = new Mock <IFileNameService>();
var fileName = "DesktopFundingSummaryReport.xlsx";
fileNameServiceMock.Setup(s => s.GetFilename(reportServiceContextMock.Object, "Funding Summary Report", OutputTypes.Excel, true)).Returns(fileName);
var fundingSummaryReportRenderService = new FundingSummaryReportRenderService();
var report = NewReport(
fileNameServiceMock.Object,
fundingSummaryReportModelBuilder,
excelService.Object,
fundingSummaryReportRenderService);
var cancellationToken = CancellationToken.None;
await report.GenerateAsync(reportServiceContextMock.Object, reportServiceDependentDataMock.Object, cancellationToken);
}
private IDictionary <string, string> BuildHeaderData(IReportServiceContext reportServiceContext, ReferenceDataRoot referenceDataRoot)
{
var organisationName = referenceDataRoot.Organisations.FirstOrDefault(o => o.UKPRN == reportServiceContext.Ukprn)?.Name ?? string.Empty;
return(new Dictionary <string, string>()
{
{ SummaryPageConstants.ProviderName, organisationName },
{ SummaryPageConstants.UKPRN, reportServiceContext.Ukprn.ToString() },
{ SummaryPageConstants.ILRFile, reportServiceContext.IlrReportingFilename },
{ SummaryPageConstants.LastILRFileUpdate, reportServiceContext.LastIlrFileUpdate },
{ SummaryPageConstants.EASFile, reportServiceContext.EasReportingFilename },
{ SummaryPageConstants.LastEASFileUpdate, reportServiceContext.LastEasFileUpdate },
{ SummaryPageConstants.SecurityClassification, ReportingConstants.OfficialSensitive }
});
}
public void BuildTest()
{
var dependentDataMock = new Mock <IReportServiceDependentData>();
var referenceDataRoot = new ReferenceDataRoot()
{
Organisations = new List <Organisation>()
{
new Organisation()
{
UKPRN = 987654321,
Name = "Provider XYZ",
OrganisationCoFRemovals = new List <OrganisationCoFRemoval>()
{
new OrganisationCoFRemoval()
{
EffectiveFrom = new DateTime(2019, 01, 01),
CoFRemoval = (decimal)4500.12
}
},
}
},
MetaDatas = new MetaData()
{
ReferenceDataVersions = new ReferenceDataVersion()
{
OrganisationsVersion = new OrganisationsVersion {
Version = "1.1.1.1"
},
Employers = new EmployersVersion {
Version = "2.2.2.2"
},
LarsVersion = new LarsVersion {
Version = "3.3.3.3"
},
PostcodesVersion = new PostcodesVersion {
Version = "4.4.4.4"
},
CampusIdentifierVersion = new CampusIdentifierVersion()
{
Version = "5.5.5.5"
},
EasFileDetails = new EasFileDetails {
UploadDateTime = new DateTime(2020, 1, 1, 1, 1, 1)
}
}
}
};
var easFundingLines = BuildEasFundingLines();
var fm35Learner = new FM35Learner
{
LearnRefNumber = "Learner1",
LearningDeliveries = BuildFm35LearningDeliveries()
};
var fm35Global = new FM35Global()
{
Learners = new List <FM35Learner>()
{
fm35Learner
}
};
var albLearner = new ALBLearner()
{
LearnRefNumber = "Learner1",
LearningDeliveries = BuildAlbLearningDeliveries()
};
var albGlobal = new ALBGlobal()
{
Learners = new List <ALBLearner>()
{
albLearner
}
};
dependentDataMock.Setup(d => d.Get <ReferenceDataRoot>()).Returns(referenceDataRoot);
dependentDataMock.Setup(d => d.Get <FM35Global>()).Returns(fm35Global);
dependentDataMock.Setup(d => d.Get <ALBGlobal>()).Returns(albGlobal);
dependentDataMock.Setup(d => d.Get <List <EasFundingLine> >()).Returns(easFundingLines);
var submissionDateTime = new DateTime(2020, 1, 1, 1, 1, 1);
var ukDateTime = new DateTime(2020, 1, 1, 1, 1, 1);
var dateTimeProvider = new Mock <IDateTimeProvider>();
var reportServiceContextMock = new Mock <IReportServiceContext>();
reportServiceContextMock.SetupGet(c => c.Ukprn).Returns(987654321);
reportServiceContextMock.SetupGet(c => c.SubmissionDateTimeUtc).Returns(submissionDateTime);
reportServiceContextMock.SetupGet(c => c.ServiceReleaseVersion).Returns("11.22.3300.4321");
reportServiceContextMock.SetupGet(c => c.IlrReportingFilename).Returns("ILR-12345678-2021-20201005-151322-01.xml");
reportServiceContextMock.SetupGet(c => c.EasReportingFilename).Returns("EAS-12345678-2021-20201005-151322-01.csv");
dateTimeProvider.Setup(p => p.GetNowUtc()).Returns(submissionDateTime);
dateTimeProvider.SetupSequence(p => p.ConvertUtcToUk(It.IsAny <DateTime>()))
.Returns(ukDateTime)
.Returns(new DateTime(2020, 1, 1, 1, 1, 1));
var result = NewBuilder(dateTimeProvider.Object).Build(reportServiceContextMock.Object, dependentDataMock.Object);
result.ProviderName.Should().Be("Provider XYZ");
result.Ukprn.Should().Be("987654321");
result.IlrFile.Should().Be("ILR-12345678-2021-20201005-151322-01.xml");
result.EasFile.Should().Be("EAS-12345678-2021-20201005-151322-01.csv");
result.Year.Should().Be("2020/21");
result.ReportGeneratedAt.Should().Be("Report generated at: 01:01:01 on 01/01/2020");
result.ApplicationVersion.Should().Be("11.22.3300.4321");
result.LarsData.Should().Be("3.3.3.3");
result.OrganisationData.Should().Be("1.1.1.1");
result.PostcodeData.Should().Be("4.4.4.4");
result.CampusIdData.Should().Be("5.5.5.5");
result.AEBProgrammeFunding.MidYearClaims.Should().Be(135.324m);
result.AEBProgrammeFunding.YearEndClaims.Should().Be(350.384m);
result.AEBProgrammeFunding.FinalClaims.Should().Be(489.3132m);
result.AEBLearningSupport.MidYearClaims.Should().Be(44.331m);
result.AEBLearningSupport.YearEndClaims.Should().Be(115.096m);
result.AEBLearningSupport.FinalClaims.Should().Be(161.3283m);
result.AEBProgrammeFunding1924.MidYearClaims.Should().Be(114.324m);
result.AEBProgrammeFunding1924.YearEndClaims.Should().Be(295.384m);
result.AEBProgrammeFunding1924.FinalClaims.Should().Be(411.3132m);
result.AEBLearningSupport1924.MidYearClaims.Should().Be(44.331m);
result.AEBLearningSupport1924.YearEndClaims.Should().Be(115.096m);
result.AEBLearningSupport1924.FinalClaims.Should().Be(161.3283m);
result.ALBBursaryFunding.MidYearClaims.Should().Be(23.331m);
result.ALBBursaryFunding.YearEndClaims.Should().Be(60.096m);
result.ALBBursaryFunding.FinalClaims.Should().Be(83.3283m);
result.ALBAreaCosts.MidYearClaims.Should().Be(67.662m);
result.ALBAreaCosts.YearEndClaims.Should().Be(175.192m);
result.ALBAreaCosts.FinalClaims.Should().Be(244.6566m);
result.ALBExcessSupport.MidYearClaims.Should().Be(21m);
result.ALBExcessSupport.YearEndClaims.Should().Be(55m);
result.ALBExcessSupport.FinalClaims.Should().Be(78m);
}
public void BuildTest()
{
var dependentDataMock = new Mock <IReportServiceDependentData>();
var learningDeliveryFam = new Mock <ILearningDeliveryFAM>();
learningDeliveryFam.SetupGet(fam => fam.LearnDelFAMType).Returns("SOF");
learningDeliveryFam.SetupGet(fam => fam.LearnDelFAMCode).Returns("107");
var albLearningDeliveryFam = new Mock <ILearningDeliveryFAM>();
albLearningDeliveryFam.SetupGet(fam => fam.LearnDelFAMType).Returns("ALB");
var learningDeliveryFams = new List <ILearningDeliveryFAM>()
{
learningDeliveryFam.Object,
albLearningDeliveryFam.Object
};
var learningDelivery = new TestLearningDelivery()
{
FundModel = 25,
LearnAimRef = "learnAimRef",
AimSeqNumber = 1,
LearningDeliveryFAMs = learningDeliveryFams,
StdCodeNullable = 1,
};
var message = new TestMessage()
{
Learners = BuildLearners(learningDelivery),
HeaderEntity = new TestHeader()
{
CollectionDetailsEntity = new MessageHeaderCollectionDetails()
{
FilePreparationDate = new DateTime(2019, 11, 06)
}
}
};
var referenceDataRoot = new ReferenceDataRoot()
{
Organisations = new List <Organisation>()
{
new Organisation()
{
UKPRN = 987654321,
Name = "Provider XYZ",
OrganisationCoFRemovals = new List <OrganisationCoFRemoval>()
{
new OrganisationCoFRemoval()
{
EffectiveFrom = new DateTime(2019, 01, 01),
CoFRemoval = (decimal)4500.12
}
},
}
},
MetaDatas = new MetaData()
{
ReferenceDataVersions = new ReferenceDataVersion()
{
OrganisationsVersion = new OrganisationsVersion {
Version = "1.1.1.1"
},
Employers = new EmployersVersion {
Version = "2.2.2.2"
},
LarsVersion = new LarsVersion {
Version = "3.3.3.3"
},
PostcodesVersion = new PostcodesVersion {
Version = "4.4.4.4"
},
CoFVersion = new CoFVersion()
{
Version = "5.5.5.5"
}
}
}
};
var fm25Global = new FM25Global()
{
Learners = BuildFm25Learners()
};
dependentDataMock.Setup(d => d.Get <IMessage>()).Returns(message);
dependentDataMock.Setup(d => d.Get <ReferenceDataRoot>()).Returns(referenceDataRoot);
dependentDataMock.Setup(d => d.Get <FM25Global>()).Returns(fm25Global);
var submissionDateTime = new DateTime(2019, 1, 1, 1, 1, 1);
var ukDateTime = new DateTime(2020, 1, 1, 1, 1, 1);
var dateTimeProvider = new Mock <IDateTimeProvider>();
var reportServiceContextMock = new Mock <IReportServiceContext>();
reportServiceContextMock.SetupGet(c => c.Ukprn).Returns(987654321);
reportServiceContextMock.SetupGet(c => c.SubmissionDateTimeUtc).Returns(submissionDateTime);
reportServiceContextMock.SetupGet(c => c.ServiceReleaseVersion).Returns("11.22.3300.4321");
reportServiceContextMock.SetupGet(c => c.IlrReportingFilename).Returns("ILR-12345678-1920-20191005-151322-01.xml");
dateTimeProvider.Setup(p => p.ConvertUtcToUk(submissionDateTime)).Returns(ukDateTime);
dateTimeProvider.Setup(p => p.GetNowUtc()).Returns(submissionDateTime);
var result = NewBuilder(dateTimeProvider.Object).Build(reportServiceContextMock.Object, dependentDataMock.Object);
result.ApplicationVersion.Should().Be("11.22.3300.4321");
result.ComponentSetVersion.Should().Be("NA");
result.FilePreparationDate.Should().Be("06/11/2019");
result.IlrFile.Should().Be("ILR-12345678-1920-20191005-151322-01.xml");
result.LargeEmployerData.Should().Be("2.2.2.2");
result.LarsData.Should().Be("3.3.3.3");
result.OrganisationData.Should().Be("1.1.1.1");
result.PostcodeData.Should().Be("4.4.4.4");
result.CofRemovalData.Should().Be("5.5.5.5");
result.ProviderName.Should().Be("Provider XYZ");
result.ReportGeneratedAt.Should().Be("Report generated at: 01:01:01 on 01/01/2020");
result.Ukprn.Should().Be("987654321");
result.Year.Should().Be("2020/21");
result.CofRemoval.Should().Be((decimal) - 4500.12);
result.ReferenceDate.Should().Be("(ALL)");
result.FundingFactor.PrvRetentFactHist.Should().Be("0.79600");
result.FundingFactor.ProgWeightHist.Should().Be("1.06100");
result.FundingFactor.AreaCostFact1618Hist.Should().Be("1.00000");
result.FundingFactor.PrvDisadvPropnHist.Should().Be("0.34500");
result.FundingFactor.PrvHistLrgProgPropn.Should().Be("0.21300");
result.FundingFactor.PrvHistL3ProgMathEngProp.Should().Be("0.21300");
result.DirectFundingStudents.Band1StudentNumbers.Should().Be(0);
result.DirectFundingStudents.Band2StudentNumbers.Should().Be(0);
result.DirectFundingStudents.Band3StudentNumbers.Should().Be(0);
result.DirectFundingStudents.Band4aStudentNumbers.Should().Be(1);
result.DirectFundingStudents.Band4bStudentNumbers.Should().Be(0);
result.DirectFundingStudents.Band5StudentNumbers.Should().Be(1);
result.DirectFundingStudents.Band6StudentNumbers.Should().Be(0);
result.DirectFundingStudents.Band7StudentNumbers.Should().Be(0);
result.DirectFundingStudents.Band8StudentNumbers.Should().Be(0);
result.DirectFundingStudents.Band9StudentNumbers.Should().Be(0);
result.DirectFundingStudents.Band1To5StudentNumbersTLevel.Should().Be(0);
result.StudentsIncludingHNS.Band1StudentNumbers.Should().Be(0);
result.StudentsIncludingHNS.Band1TotalFunding.Should().Be(0);
result.StudentsIncludingHNS.Band2StudentNumbers.Should().Be(0);
result.StudentsIncludingHNS.Band2TotalFunding.Should().Be(0);
result.StudentsIncludingHNS.Band3StudentNumbers.Should().Be(1);
result.StudentsIncludingHNS.Band3TotalFunding.Should().Be((decimal)25815.43);
result.StudentsIncludingHNS.Band4aStudentNumbers.Should().Be(0);
result.StudentsIncludingHNS.Band4aTotalFunding.Should().Be(0);
result.StudentsIncludingHNS.Band4bStudentNumbers.Should().Be(1);
result.StudentsIncludingHNS.Band4bTotalFunding.Should().Be((decimal)2589915.43);
result.StudentsIncludingHNS.Band5StudentNumbers.Should().Be(0);
result.StudentsIncludingHNS.Band5TotalFunding.Should().Be(0);
result.StudentsIncludingHNS.Band6StudentNumbers.Should().Be(0);
result.StudentsIncludingHNS.Band6TotalFunding.Should().Be(0);
result.StudentsIncludingHNS.Band7StudentNumbers.Should().Be(0);
result.StudentsIncludingHNS.Band7TotalFunding.Should().Be(0);
result.StudentsIncludingHNS.Band8StudentNumbers.Should().Be(0);
result.StudentsIncludingHNS.Band8TotalFunding.Should().Be(0);
result.StudentsIncludingHNS.Band9StudentNumbers.Should().Be(0);
result.StudentsIncludingHNS.Band9TotalFunding.Should().Be(0);
result.StudentsIncludingHNS.Band1To5StudentNumbersTLevel.Should().Be(0);
result.StudentsIncludingHNS.Band1To5TotalFundingTLevel.Should().Be(0);
result.StudentsWithEHCPlan.Band1StudentNumbers.Should().Be(1);
result.StudentsWithEHCPlan.Band1TotalFunding.Should().Be((decimal)125.67);
result.StudentsWithEHCPlan.Band2StudentNumbers.Should().Be(1);
result.StudentsWithEHCPlan.Band2TotalFunding.Should().Be((decimal)555.12);
result.StudentsWithEHCPlan.Band3StudentNumbers.Should().Be(0);
result.StudentsWithEHCPlan.Band3TotalFunding.Should().Be(0);
result.StudentsWithEHCPlan.Band4aStudentNumbers.Should().Be(0);
result.StudentsWithEHCPlan.Band4aTotalFunding.Should().Be(0);
result.StudentsWithEHCPlan.Band4bStudentNumbers.Should().Be(0);
result.StudentsWithEHCPlan.Band4bTotalFunding.Should().Be(0);
result.StudentsWithEHCPlan.Band5StudentNumbers.Should().Be(0);
result.StudentsWithEHCPlan.Band5TotalFunding.Should().Be(0);
result.StudentsWithEHCPlan.Band6StudentNumbers.Should().Be(0);
result.StudentsWithEHCPlan.Band6TotalFunding.Should().Be(0);
result.StudentsWithEHCPlan.Band7StudentNumbers.Should().Be(1);
result.StudentsWithEHCPlan.Band7TotalFunding.Should().Be((decimal)125.67);
result.StudentsWithEHCPlan.Band8StudentNumbers.Should().Be(0);
result.StudentsWithEHCPlan.Band8TotalFunding.Should().Be(0);
result.StudentsWithEHCPlan.Band9StudentNumbers.Should().Be(0);
result.StudentsWithEHCPlan.Band9TotalFunding.Should().Be(0);
result.StudentsWithEHCPlan.Band1To5StudentNumbersTLevel.Should().Be(0);
result.StudentsWithEHCPlan.Band1To5TotalFundingTLevel.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band1StudentNumbers.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band1TotalFunding.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band2StudentNumbers.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band2TotalFunding.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band3StudentNumbers.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band3TotalFunding.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band4aStudentNumbers.Should().Be(1);
result.ContinuingStudentsExcludingEHCPlan.Band4aTotalFunding.Should().Be((decimal)855.55);
result.ContinuingStudentsExcludingEHCPlan.Band4bStudentNumbers.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band4bTotalFunding.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band5StudentNumbers.Should().Be(1);
result.ContinuingStudentsExcludingEHCPlan.Band5TotalFunding.Should().Be((decimal)56425.99);
result.ContinuingStudentsExcludingEHCPlan.Band6StudentNumbers.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band6TotalFunding.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band7StudentNumbers.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band7TotalFunding.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band8StudentNumbers.Should().Be(1);
result.ContinuingStudentsExcludingEHCPlan.Band8TotalFunding.Should().Be((decimal)56425.99);
result.ContinuingStudentsExcludingEHCPlan.Band9StudentNumbers.Should().Be(1);
result.ContinuingStudentsExcludingEHCPlan.Band9TotalFunding.Should().Be((decimal)855.55);
result.ContinuingStudentsExcludingEHCPlan.Band1To5StudentNumbersTLevel.Should().Be(0);
result.ContinuingStudentsExcludingEHCPlan.Band1To5TotalFundingTLevel.Should().Be(0);
}
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 }
});
}
public void Build_NoLearners()
{
var dependentDataMock = new Mock <IReportServiceDependentData>();
var message = new TestMessage()
{
Learners = new List <TestLearner>(),
HeaderEntity = new TestHeader()
{
CollectionDetailsEntity = new MessageHeaderCollectionDetails()
{
FilePreparationDate = new DateTime(2019, 11, 06)
}
}
};
var referenceDataRoot = new ReferenceDataRoot()
{
Organisations = new List <Organisation>()
{
new Organisation()
{
UKPRN = 987654321,
Name = "Provider XYZ",
OrganisationCoFRemovals = new List <OrganisationCoFRemoval>()
{
new OrganisationCoFRemoval()
{
EffectiveFrom = new DateTime(2019, 01, 01),
CoFRemoval = (decimal)4500.12
}
},
}
},
MetaDatas = new MetaData()
{
ReferenceDataVersions = new ReferenceDataVersion()
{
OrganisationsVersion = new OrganisationsVersion {
Version = "1.1.1.1"
},
Employers = new EmployersVersion {
Version = "2.2.2.2"
},
LarsVersion = new LarsVersion {
Version = "3.3.3.3"
},
PostcodesVersion = new PostcodesVersion {
Version = "4.4.4.4"
},
CoFVersion = new CoFVersion()
{
Version = "5.5.5.5"
}
}
}
};
var fm25Global = new FM25Global()
{
Learners = new List <FM25Learner>()
};
dependentDataMock.Setup(d => d.Get <IMessage>()).Returns(message);
dependentDataMock.Setup(d => d.Get <ReferenceDataRoot>()).Returns(referenceDataRoot);
dependentDataMock.Setup(d => d.Get <FM25Global>()).Returns(fm25Global);
var submissionDateTime = new DateTime(2019, 1, 1, 1, 1, 1);
var ukDateTime = new DateTime(2020, 1, 1, 1, 1, 1);
var dateTimeProvider = new Mock <IDateTimeProvider>();
var reportServiceContextMock = new Mock <IReportServiceContext>();
reportServiceContextMock.SetupGet(c => c.Ukprn).Returns(987654321);
reportServiceContextMock.SetupGet(c => c.SubmissionDateTimeUtc).Returns(submissionDateTime);
reportServiceContextMock.SetupGet(c => c.ServiceReleaseVersion).Returns("11.22.3300.4321");
reportServiceContextMock.SetupGet(c => c.IlrReportingFilename).Returns("ILR-12345678-1920-20191005-151322-01.xml");
dateTimeProvider.Setup(p => p.ConvertUtcToUk(submissionDateTime)).Returns(ukDateTime);
dateTimeProvider.Setup(p => p.GetNowUtc()).Returns(submissionDateTime);
var result = NewBuilder(dateTimeProvider.Object).Build(reportServiceContextMock.Object, dependentDataMock.Object);
result.ApplicationVersion.Should().Be("11.22.3300.4321");
result.ComponentSetVersion.Should().Be("NA");
result.FilePreparationDate.Should().Be("06/11/2019");
result.IlrFile.Should().Be("ILR-12345678-1920-20191005-151322-01.xml");
result.LargeEmployerData.Should().Be("2.2.2.2");
result.LarsData.Should().Be("3.3.3.3");
result.OrganisationData.Should().Be("1.1.1.1");
result.PostcodeData.Should().Be("4.4.4.4");
result.CofRemovalData.Should().Be("5.5.5.5");
result.ProviderName.Should().Be("Provider XYZ");
result.ReportGeneratedAt.Should().Be("Report generated at: 01:01:01 on 01/01/2020");
result.Ukprn.Should().Be("987654321");
result.Year.Should().Be("2020/21");
result.CofRemoval.Should().Be((decimal) - 4500.12);
}
