public void TestMapExercises_WithStartAndEndDate()
{
createStrengthEntry(DateTime.Now, profiles[0], "t4");
createStrengthEntry(DateTime.Now.AddDays(1), profiles[0], "t3");
createStrengthEntry(DateTime.Now.AddDays(2), profiles[0], "t1");
createStrengthEntry(DateTime.Now.AddDays(3), profiles[0], "t4", "t1");
ProfileDTO profile1 = (ProfileDTO)profiles[0].Tag;
SessionData data = SecurityManager.CreateNewSession(profile1, ClientInformation);
MapperData mapperData = new MapperData();
mapperData.StartDate = DateTime.Now.AddDays(1);
mapperData.EndDate = DateTime.Now.AddDays(2);
mapperData.Entries.Add(new MapperEntry(exercises["t4"].GlobalId, exercises["t1"].GlobalId));
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
service.MapExercises(data.Token, mapperData);
});
Assert.AreEqual(2, Session.QueryOver <StrengthTrainingItem>().Where(x => x.ExerciseId == exercises["t4"].GlobalId).RowCount());
Assert.AreEqual(1, Session.QueryOver <StrengthTrainingItem>().Where(x => x.ExerciseId == exercises["t3"].GlobalId).RowCount());
Assert.AreEqual(2, Session.QueryOver <StrengthTrainingItem>().Where(x => x.ExerciseId == exercises["t1"].GlobalId).RowCount());
}
private Expression GetFallbackValueOrNull()
{
var finalDataSource = _dataSources.Last();
var fallbackValue = finalDataSource.Value;
if (finalDataSource.IsConditional || _dataSources.HasOne())
{
return(fallbackValue);
}
if (fallbackValue.NodeType == ExpressionType.Coalesce)
{
return(((BinaryExpression)fallbackValue).Right);
}
var targetMemberAccess = MapperData.GetTargetMemberAccess();
if (ExpressionEvaluation.AreEqual(fallbackValue, targetMemberAccess))
{
return(null);
}
return(fallbackValue);
}
public async void PopulateAsync()
{
var message = new TestMessage();
var cancellationToken = CancellationToken.None;
var mapperData = new MapperData();
var referenceDataVersions = TestReferenceDataVersions();
var appsEarningHistories = TestAppsEarningHistories();
var devolvedPostcodes = TestDevolvedPostcodes();
var eas = TestEas();
var employers = TestEmployers();
var epaOrgs = TestEpaOrgs();
var fcsContractAllocations = TestFcs();
var larsLearningDeliveries = TestLarsLearningDeliveries();
var larsStandards = TestLarsStandards();
var mcaContracts = TestMcaDevolvedContract();
var organisations = TestOrganisations();
var postcodes = TestPostcodes();
var ulns = TestUlnCollection();
var referenceDataContext = new Mock <IReferenceDataContext>();
var messageMapperServiceMock = new Mock <IMessageMapperService>();
var metaDataServiceMock = new Mock <IMetaDataRetrievalService>();
var appsHistoryRSMock = new Mock <IReferenceDataRetrievalService <IReadOnlyCollection <long>, IReadOnlyCollection <ApprenticeshipEarningsHistory> > >();
var devolvedPostcodesRSMock = new Mock <IReferenceDataRetrievalService <IReadOnlyCollection <string>, DevolvedPostcodes> >();
var easRSMock = new Mock <IReferenceDataRetrievalService <int, IReadOnlyCollection <EasFundingLine> > >();
var employersRSMock = new Mock <IReferenceDataRetrievalService <IReadOnlyCollection <int>, IReadOnlyCollection <Employer> > >();
var epaOrgRSMock = new Mock <IReferenceDataRetrievalService <IReadOnlyCollection <string>, IReadOnlyCollection <EPAOrganisation> > >();
var fcsRSMock = new Mock <IReferenceDataRetrievalService <int, IReadOnlyCollection <FcsContractAllocation> > >();
var larsLearningDeliveryRSMock = new Mock <IReferenceDataRetrievalService <IReadOnlyCollection <LARSLearningDeliveryKey>, IReadOnlyCollection <LARSLearningDelivery> > >();
var larsStandardRSMock = new Mock <IReferenceDataRetrievalService <IReadOnlyCollection <int>, IReadOnlyCollection <LARSStandard> > >();
var mcaDevolvedContractRSMock = new Mock <IReferenceDataRetrievalService <int, IReadOnlyCollection <McaDevolvedContract> > >();
var orgRSMock = new Mock <IReferenceDataRetrievalService <IReadOnlyCollection <int>, IReadOnlyCollection <Organisation> > >();
var postcodesRSMock = new Mock <IReferenceDataRetrievalService <IReadOnlyCollection <string>, IReadOnlyCollection <Postcode> > >();
var ulnRSMock = new Mock <IReferenceDataRetrievalService <IReadOnlyCollection <long>, IReadOnlyCollection <long> > >();
messageMapperServiceMock.Setup(s => s.MapFromMessage(message)).Returns(mapperData);
metaDataServiceMock.Setup(s => s.RetrieveAsync(mapperData.LearningProviderUKPRN, cancellationToken)).Returns(Task.FromResult(new MetaData {
ReferenceDataVersions = referenceDataVersions
}));
appsHistoryRSMock.Setup(s => s.RetrieveAsync(mapperData.FM36Ulns, cancellationToken)).Returns(Task.FromResult(appsEarningHistories));
devolvedPostcodesRSMock.Setup(s => s.RetrieveAsync(mapperData.Postcodes, cancellationToken)).Returns(Task.FromResult(devolvedPostcodes));
easRSMock.Setup(s => s.RetrieveAsync(mapperData.LearningProviderUKPRN, cancellationToken)).Returns(Task.FromResult(eas));
employersRSMock.Setup(s => s.RetrieveAsync(mapperData.EmployerIds, cancellationToken)).Returns(Task.FromResult(employers));
epaOrgRSMock.Setup(s => s.RetrieveAsync(mapperData.EpaOrgIds, cancellationToken)).Returns(Task.FromResult(epaOrgs));
fcsRSMock.Setup(s => s.RetrieveAsync(mapperData.LearningProviderUKPRN, cancellationToken)).Returns(Task.FromResult(fcsContractAllocations));
larsLearningDeliveryRSMock.Setup(s => s.RetrieveAsync(mapperData.LARSLearningDeliveryKeys, cancellationToken)).Returns(Task.FromResult(larsLearningDeliveries));
larsStandardRSMock.Setup(s => s.RetrieveAsync(mapperData.StandardCodes, cancellationToken)).Returns(Task.FromResult(larsStandards));
mcaDevolvedContractRSMock.Setup(s => s.RetrieveAsync(mapperData.LearningProviderUKPRN, cancellationToken)).Returns(Task.FromResult(mcaContracts));
orgRSMock.Setup(s => s.RetrieveAsync(mapperData.UKPRNs, cancellationToken)).Returns(Task.FromResult(organisations));
postcodesRSMock.Setup(s => s.RetrieveAsync(mapperData.Postcodes, cancellationToken)).Returns(Task.FromResult(postcodes));
ulnRSMock.Setup(s => s.RetrieveAsync(mapperData.ULNs, cancellationToken)).Returns(Task.FromResult(ulns));
var root = await NewService(
messageMapperServiceMock.Object,
metaDataServiceMock.Object,
appsHistoryRSMock.Object,
devolvedPostcodesRSMock.Object,
easRSMock.Object,
employersRSMock.Object,
epaOrgRSMock.Object,
fcsRSMock.Object,
larsLearningDeliveryRSMock.Object,
larsStandardRSMock.Object,
mcaDevolvedContractRSMock.Object,
orgRSMock.Object,
postcodesRSMock.Object,
ulnRSMock.Object).PopulateAsync(referenceDataContext.Object, message, CancellationToken.None);
root.MetaDatas.ReferenceDataVersions.Should().BeEquivalentTo(referenceDataVersions);
root.AppsEarningsHistories.Should().HaveCount(2);
root.Employers.Should().HaveCount(3);
root.EPAOrganisations.Should().HaveCount(3);
root.FCSContractAllocations.Should().HaveCount(2);
root.LARSLearningDeliveries.Should().HaveCount(2);
root.LARSStandards.Should().HaveCount(2);
root.Organisations.Should().HaveCount(2);
root.Postcodes.Should().HaveCount(2);
root.ULNs.Should().HaveCount(5);
}
public Expression GetSourceAccess(Expression contextAccess) => MapperData.GetSourceAccess(contextAccess, ContextTypes[0]);
public Expression GetTypedContextAccess(Expression contextAccess) => MapperData.GetTypedContextAccess(contextAccess, ContextTypes);
public Expression GetAppropriateMappingContextAccess(params Type[] contextTypes) => MapperData.GetAppropriateMappingContextAccess(contextTypes);
public bool ContextTypesMatch() => MapperData.TypesMatch(ContextTypes);
public Expression GetAppropriateMappingContextAccess() => MapperData.GetAppropriateMappingContextAccess(ContextTypes);
public Expression GetSourceAccess(Expression contextAccess) => MapperData.GetSourceAccess(contextAccess, SourceType);
public async Task <ReferenceDataRoot> MapReferenceData(IReferenceDataContext referenceDataContext, MapperData mapperData, CancellationToken cancellationToken)
{
var desktopReferenceData = new DesktopReferenceDataRoot();
using (var zipFileStream = await _fileService.OpenReadStreamAsync(referenceDataContext.DesktopInputReferenceDataFileKey, referenceDataContext.Container, cancellationToken))
{
using (var zip = new ZipArchive(zipFileStream, ZipArchiveMode.Read))
{
_logger.LogInfo("Reference Data - Retrieve MetaData");
desktopReferenceData.MetaDatas = _zipArchiveFileService.RetrieveModel <MetaData>(zip, DesktopReferenceDataConstants.MetaDataFile);
_logger.LogInfo("Reference Data - Retrieve Devolved Postcodes");
desktopReferenceData.DevolvedPostcodes = GetDevolvedPostcodes(zip, mapperData.Postcodes);
_logger.LogInfo("Reference Data - Retrieve Employers");
desktopReferenceData.Employers = _zipArchiveFileService.RetrieveModels <Employer>(zip, DesktopReferenceDataConstants.EmployersFile, x => mapperData.EmployerIds.Contains(x.ERN));
_logger.LogInfo("Reference Data - Retrieve Epa Organisations");
desktopReferenceData.EPAOrganisations = _zipArchiveFileService.RetrieveModels <EPAOrganisation>(zip, DesktopReferenceDataConstants.EPAOrganisationsFile, x => mapperData.EpaOrgIds.Contains(x.ID));
_logger.LogInfo("Reference Data - Retrieve Lars Frameworks");
desktopReferenceData.LARSFrameworks = _zipArchiveFileService.RetrieveModels <LARSFrameworkDesktop>(zip, DesktopReferenceDataConstants.LARSFrameworksFile);
_logger.LogInfo("Reference Data - Retrieve Lars Framework Aims");
desktopReferenceData.LARSFrameworkAims = _zipArchiveFileService.RetrieveModels <LARSFrameworkAimDesktop>(zip, DesktopReferenceDataConstants.LARSFrameworkAimsFile);
_logger.LogInfo("Reference Data - Retrieve Lars Learning Deliveries");
desktopReferenceData.LARSLearningDeliveries = _zipArchiveFileService.RetrieveModels <LARSLearningDelivery>(zip, DesktopReferenceDataConstants.LARSLearningDeliveriesFile, x => mapperData.LARSLearningDeliveryKeys.Select(l => l.LearnAimRef).Contains(x.LearnAimRef, StringComparer.OrdinalIgnoreCase));
_logger.LogInfo("Reference Data - Retrieve Lars Standards");
desktopReferenceData.LARSStandards = _zipArchiveFileService.RetrieveModels <LARSStandard>(zip, DesktopReferenceDataConstants.LARSStandardsFile, x => mapperData.StandardCodes.Contains(x.StandardCode));
_logger.LogInfo("Reference Data - Retrieve Organisations");
desktopReferenceData.Organisations = _zipArchiveFileService.RetrieveModels <Organisation>(zip, DesktopReferenceDataConstants.OrganisationsFile, x => mapperData.UKPRNs.Contains(x.UKPRN));
_logger.LogInfo("Reference Data - Retrieve Postcodes");
desktopReferenceData.Postcodes = _zipArchiveFileService.RetrieveModels <Postcode>(zip, DesktopReferenceDataConstants.PostcodesFile, x => mapperData.Postcodes.Contains(x.PostCode));
}
}
var referenceDataRoot = MapData(desktopReferenceData, mapperData);
return(referenceDataRoot);
}
private ReferenceDataRoot MapData(DesktopReferenceDataRoot desktopReferenceData, MapperData mapperData)
{
return(new ReferenceDataRoot
{
MetaDatas = desktopReferenceData.MetaDatas,
DevolvedPostcodes = desktopReferenceData.DevolvedPostcodes,
Employers = desktopReferenceData.Employers,
EPAOrganisations = desktopReferenceData.EPAOrganisations,
LARSLearningDeliveries = _larsLearningDeliveryMapperService.Map(mapperData.LARSLearningDeliveryKeys, desktopReferenceData),
LARSStandards = desktopReferenceData.LARSStandards,
Organisations = desktopReferenceData.Organisations,
Postcodes = desktopReferenceData.Postcodes,
});
}
public MappingModel(MapperData mapperData)
{
this.mapperData = mapperData;
}
public async Task Retrieve()
{
var cancellationToken = CancellationToken.None;
var fileServiceMock = new Mock <IFileService>();
var zipArchiveFileServiceMock = new Mock <IZipArchiveFileService>();
var referenceDataContext = new Mock <IReferenceDataContext>();
var mapperData = new MapperData
{
Postcodes = new List <string> {
"Postcode1"
},
EmployerIds = new List <int> {
1
},
EpaOrgIds = new List <string> {
"1", "2", "3"
},
UKPRNs = new List <int> {
1, 2, 3
},
StandardCodes = new List <int> {
1, 2, 3
},
LARSLearningDeliveryKeys = new List <LARSLearningDeliveryKey>
{
new LARSLearningDeliveryKey("1", 1, 1, 1)
}
};
var larsLearningDeliveries = new List <LARSLearningDelivery>
{
new LARSLearningDelivery
{
LearnAimRef = "1",
LARSFrameworks = new List <LARSFramework>
{
new LARSFramework
{
FworkCode = 1,
ProgType = 2,
PwayCode = 3,
}
},
EffectiveFrom = new DateTime(2018, 8, 1),
},
new LARSLearningDelivery
{
LearnAimRef = "2",
EffectiveFrom = new DateTime(2018, 8, 1),
LARSFrameworks = new List <LARSFramework>
{
new LARSFramework
{
FworkCode = 2,
ProgType = 2,
PwayCode = 3,
}
}
},
new LARSLearningDelivery
{
LearnAimRef = "3",
EffectiveFrom = new DateTime(2018, 8, 1),
},
};
var expectedReferenceData = new ReferenceDataRoot
{
MetaDatas = TestNetaData(),
DevolvedPostcodes = new DevolvedPostcodes
{
McaGlaSofLookups = TestMcaSofLookups(),
Postcodes = TestDevolvedPostcodes(),
},
Employers = TestEmployers(),
EPAOrganisations = TestEpaOrgs(),
LARSLearningDeliveries = larsLearningDeliveries,
LARSStandards = TestLarsStandards(),
Organisations = TestOrganisations(),
Postcodes = TestPostcodes()
};
var currentPath = Directory.GetCurrentDirectory();
referenceDataContext.Setup(r => r.DesktopInputReferenceDataFileKey).Returns("ReferenceData.zip");
referenceDataContext.Setup(r => r.Container).Returns(currentPath);
zipArchiveFileServiceMock.Setup(zs => zs.RetrieveModel <MetaData>(It.IsAny <ZipArchive>(), It.IsAny <string>())).Returns(TestNetaData());
zipArchiveFileServiceMock.Setup(zs => zs.RetrieveModels <DevolvedPostcode>(It.IsAny <ZipArchive>(), It.IsAny <string>(), It.IsAny <Func <DevolvedPostcode, bool> >())).Returns(TestDevolvedPostcodes());
zipArchiveFileServiceMock.Setup(zs => zs.RetrieveModels <McaGlaSofLookup>(It.IsAny <ZipArchive>(), It.IsAny <string>(), null)).Returns(TestMcaSofLookups());
zipArchiveFileServiceMock.Setup(zs => zs.RetrieveModels <McaGlaSofLookup>(It.IsAny <ZipArchive>(), It.IsAny <string>(), null)).Returns(TestMcaSofLookups());
zipArchiveFileServiceMock.Setup(zs => zs.RetrieveModels <Employer>(It.IsAny <ZipArchive>(), It.IsAny <string>(), It.IsAny <Func <Employer, bool> >())).Returns(TestEmployers());
zipArchiveFileServiceMock.Setup(zs => zs.RetrieveModels <EPAOrganisation>(It.IsAny <ZipArchive>(), It.IsAny <string>(), It.IsAny <Func <EPAOrganisation, bool> >())).Returns(TestEpaOrgs());
zipArchiveFileServiceMock.Setup(zs => zs.RetrieveModels <LARSLearningDelivery>(It.IsAny <ZipArchive>(), It.IsAny <string>(), It.IsAny <Func <LARSLearningDelivery, bool> >())).Returns(TestLarsLearningDeliveries());
zipArchiveFileServiceMock.Setup(zs => zs.RetrieveModels <LARSFrameworkDesktop>(It.IsAny <ZipArchive>(), It.IsAny <string>(), null)).Returns(TestLarsFrameworks());
zipArchiveFileServiceMock.Setup(zs => zs.RetrieveModels <LARSFrameworkAimDesktop>(It.IsAny <ZipArchive>(), It.IsAny <string>(), null)).Returns(new List <LARSFrameworkAimDesktop>());
zipArchiveFileServiceMock.Setup(zs => zs.RetrieveModels <LARSStandard>(It.IsAny <ZipArchive>(), It.IsAny <string>(), It.IsAny <Func <LARSStandard, bool> >())).Returns(TestLarsStandards());
zipArchiveFileServiceMock.Setup(zs => zs.RetrieveModels <Organisation>(It.IsAny <ZipArchive>(), It.IsAny <string>(), It.IsAny <Func <Organisation, bool> >())).Returns(TestOrganisations());
zipArchiveFileServiceMock.Setup(zs => zs.RetrieveModels <Postcode>(It.IsAny <ZipArchive>(), It.IsAny <string>(), It.IsAny <Func <Postcode, bool> >())).Returns(TestPostcodes());
var larsLearningDeliveryMapperServiceMock = new Mock <IDesktopReferenceDataMapper <IReadOnlyCollection <LARSLearningDeliveryKey>, IReadOnlyCollection <LARSLearningDelivery> > >();
larsLearningDeliveryMapperServiceMock.Setup(sm => sm.Map(It.IsAny <List <LARSLearningDeliveryKey> >(), It.IsAny <DesktopReferenceDataRoot>())).Returns(larsLearningDeliveries);
using (Stream stream = new FileStream(currentPath + "\\TestFiles\\ReferenceData.zip", FileMode.Open))
{
fileServiceMock.Setup(fs => fs.OpenReadStreamAsync(
referenceDataContext.Object.DesktopInputReferenceDataFileKey,
referenceDataContext.Object.Container,
cancellationToken)).ReturnsAsync(stream);
var result = await NewService(
zipArchiveFileServiceMock.Object,
larsLearningDeliveryMapperServiceMock.Object,
fileServiceMock.Object)
.MapReferenceData(referenceDataContext.Object, mapperData, cancellationToken);
result.Should().BeEquivalentTo(expectedReferenceData);
}
}
public void Fill()
{
data = new MapperData();
refreshGrid();
}
private Expression GetTargetObjectAccess() => MapperData.GetTargetAccess(_contextAccess, _args.ContextTargetType);
public MapperResult MapExercises(Token token, MapperData data)
{
throw new NotImplementedException();
}
private Expression GetTargetMemberKey() => TargetMemberKey ?? MapperData.GetTargetMemberDictionaryKey();
public Mapper(string fileName, bool vitalsignsDatabase = true)
{
MapperData = MappingHelper.GetMapingData(fileName);
VitalSignsDatabase = vitalsignsDatabase;
}
