Beispiel #1
0
        public void GetLearningDeliveryForRecordKey_NoMatch()
        {
            var nonMatchingLearningDelivery = new LearningDeliveryBuilder()
                                              .With(ld => ld.LearnAimRef, "NotLearnAimRef")
                                              .Build();

            var learningDeliveries = new List <LearningDelivery>()
            {
                nonMatchingLearningDelivery,
            };

            var learner = new LearnerBuilder()
                          .With(l => l.LearningDeliveries, learningDeliveries)
                          .Build();

            var recordKey = new RecordKey(
                "1",
                123456789,
                "LearnAimRef",
                new DateTime(2020, 8, 1),
                20,
                40,
                10,
                30,
                "ReportingAimFundingLineType",
                "PriceEpisodeIdentifier",
                1);

            NewBuilder().GetLearnerLearningDeliveryForRecord(learner, recordKey).Should().BeNull();
        }
Beispiel #2
0
        public void GetLearningDeliveryForRecordKey()
        {
            var matchingLearningDelivery = new LearningDeliveryBuilder()
                                           .With(ld => ld.LearnRefNumber, "LearningRefNumber")
                                           .Build();

            var nonMatchingLearningDelivery = new LearningDeliveryBuilder()
                                              .With(ld => ld.LearnRefNumber, "NotLearningRefNumber")
                                              .Build();

            var learningDeliveries = new List <LearningDelivery>()
            {
                matchingLearningDelivery,
                nonMatchingLearningDelivery,
            };

            var learner = new LearnerBuilder()
                          .With(l => l.LearningDeliveries, learningDeliveries)
                          .Build();

            var recordKey = new AppsCoInvestmentRecordKey(
                "LearnRefNumber",
                new DateTime(2020, 8, 1),
                20,
                40,
                10,
                30);

            NewBuilder().GetLearningDeliveryForRecord(learner, recordKey).Should().BeSameAs(matchingLearningDelivery);
        }
Beispiel #3
0
        public void GetLearnerEmploymentStatus_EmptySet()
        {
            var learner = new LearnerBuilder()
                          .With(l => l.LearnerEmploymentStatuses, new List <LearnerEmploymentStatus>())
                          .Build();

            NewBuilder().GetLearnerEmploymentStatus(learner, null).Should().BeNull();
        }
Beispiel #4
0
        public void GetLearnerEmploymentStatus_NullLearnEmploymentStatus()
        {
            var learner = new LearnerBuilder()
                          .With(l => l.LearnerEmploymentStatuses, null)
                          .Build();

            NewBuilder().GetLearnerEmploymentStatus(learner, new LearningDeliveryBuilder().Build()).Should().BeNull();
        }
        public void BuildProviderSpecLearnMonitoringsForLearner_NullProviderMons()
        {
            var learner = new LearnerBuilder().With(l => l.ProviderSpecLearnMonitorings, null).Build();

            var learningDelivery = new LearningDeliveryBuilder().With(ld => ld.ProviderSpecDeliveryMonitorings, null).Build();

            NewBuilder().BuildProviderMonitorings(learner, learningDelivery).Should().BeNull();
        }
Beispiel #6
0
        public void BuildLearnerLookup()
        {
            var learnerOne = new LearnerBuilder().With(l => l.LearnRefNumber, "One").Build();
            var learnerTwo = new LearnerBuilder().With(l => l.LearnRefNumber, "Two").Build();

            var learners = new List <Learner>()
            {
                learnerOne,
                learnerTwo,
            };

            var learnerLookup = NewBuilder().BuildLearnerLookup(learners);

            learnerLookup.Should().HaveCount(2);

            learnerLookup["One"].Should().Be(learnerOne);
            learnerLookup["Two"].Should().Be(learnerTwo);
        }
Beispiel #7
0
        public void GetLearnerEmploymentStatus_MultipleBeforeLearnStartDate()
        {
            var learnerEmploymentStatusOne = new LearnerEmploymentStatusBuilder().With(s => s.DateEmpStatApp, new DateTime(2020, 6, 1)).Build();
            var learnerEmploymentStatusTwo = new LearnerEmploymentStatusBuilder().With(s => s.DateEmpStatApp, new DateTime(2020, 7, 1)).Build();

            var learner = new LearnerBuilder()
                          .With(
                l => l.LearnerEmploymentStatuses,
                new List <LearnerEmploymentStatus>()
            {
                learnerEmploymentStatusOne,
                learnerEmploymentStatusTwo,
            })
                          .Build();

            var learningDelivery = new LearningDeliveryBuilder().With(ld => ld.LearnStartDate, new DateTime(2020, 8, 1)).Build();

            NewBuilder().GetLearnerEmploymentStatus(learner, learningDelivery).Should().BeSameAs(learnerEmploymentStatusTwo);
        }
Beispiel #8
0
        public void GetLearningDeliveryForRecordKey_NullLearningDeliveries()
        {
            var learner = new LearnerBuilder()
                          .With(l => l.LearningDeliveries, null)
                          .Build();

            var recordKey = new RecordKey(
                "1",
                123456789,
                "LearnAimRef",
                new DateTime(2020, 8, 1),
                20,
                40,
                10,
                30,
                "ReportingAimFundingLineType",
                "PriceEpisodeIdentifier",
                1);

            NewBuilder().GetLearnerLearningDeliveryForRecord(learner, recordKey).Should().BeNull();
        }
Beispiel #9
0
        public void GetLearnerEmploymentStatus()
        {
            var learnerEmploymentStatusEarliest = new LearnerEmploymentStatusBuilder().With(s => s.DateEmpStatApp, new DateTime(2020, 6, 1)).Build();
            var learnerEmploymentStatusAfter    = new LearnerEmploymentStatusBuilder().With(s => s.DateEmpStatApp, new DateTime(2020, 10, 1)).Build();
            var learnerEmploymentStatusLatest   = new LearnerEmploymentStatusBuilder().With(s => s.DateEmpStatApp, new DateTime(2020, 7, 1)).Build();

            var learner = new LearnerBuilder()
                          .With(
                l => l.LearnerEmploymentStatuses,
                new List <LearnerEmploymentStatus>()
            {
                learnerEmploymentStatusEarliest,
                learnerEmploymentStatusAfter,
                learnerEmploymentStatusLatest,
            })
                          .Build();

            var learningDelivery = new LearningDeliveryBuilder().With(ld => ld.LearnStartDate, new DateTime(2020, 8, 1)).Build();

            NewBuilder().GetLearnerEmploymentStatus(learner, learningDelivery).Should().BeSameAs(learnerEmploymentStatusLatest);
        }
        public void BuildProviderMonitorings()
        {
            var providerLearnerMonA = new ProviderMonitoringBuilder().With(m => m.Occur, "A").With(m => m.Mon, "MonA").Build();
            var providerLearnerMonB = new ProviderMonitoringBuilder().With(m => m.Occur, "B").With(m => m.Mon, "MonB").Build();

            var providerLearnerMonitorings = new List <ProviderMonitoring>()
            {
                providerLearnerMonA,
                providerLearnerMonB,
            };

            var learner = new LearnerBuilder().With(l => l.ProviderSpecLearnMonitorings, providerLearnerMonitorings).Build();

            var providerLearnDelMonA = new ProviderMonitoringBuilder().With(m => m.Occur, "A").With(m => m.Mon, "DelMonA").Build();
            var providerLearnDelMonB = new ProviderMonitoringBuilder().With(m => m.Occur, "B").With(m => m.Mon, "DelMonB").Build();
            var providerLearnDelMonC = new ProviderMonitoringBuilder().With(m => m.Occur, "C").With(m => m.Mon, "DelMonC").Build();
            var providerLearnDelMonD = new ProviderMonitoringBuilder().With(m => m.Occur, "D").With(m => m.Mon, "DelMonD").Build();

            var providerLearnDelMonitorings = new List <ProviderMonitoring>()
            {
                providerLearnDelMonA,
                providerLearnDelMonB,
                providerLearnDelMonC,
                providerLearnDelMonD,
            };

            var learningDelivery = new LearningDeliveryBuilder().With(ld => ld.ProviderSpecDeliveryMonitorings, providerLearnDelMonitorings).Build();

            var providerMonitorings = NewBuilder().BuildProviderMonitorings(learner, learningDelivery);

            providerMonitorings.LearnerA.Should().Be("MonA");
            providerMonitorings.LearnerB.Should().Be("MonB");

            providerMonitorings.LearningDeliveryA.Should().Be("DelMonA");
            providerMonitorings.LearningDeliveryB.Should().Be("DelMonB");
            providerMonitorings.LearningDeliveryC.Should().Be("DelMonC");
            providerMonitorings.LearningDeliveryD.Should().Be("DelMonD");
        }
        public void BuildProviderSpecLearnMonitoringsForLearner_NonMatching()
        {
            var providerLearnerMonC = new ProviderMonitoringBuilder().With(m => m.Occur, "C").Build();
            var providerLearnerMonD = new ProviderMonitoringBuilder().With(m => m.Occur, "D").Build();

            var providerLearnerMons = new List <ProviderMonitoring>()
            {
                providerLearnerMonC,
                providerLearnerMonD,
            };

            var learner = new LearnerBuilder().With(l => l.ProviderSpecLearnMonitorings, providerLearnerMons).Build();

            var providerLearnDelMonE = new ProviderMonitoringBuilder().With(m => m.Occur, "E").With(m => m.Mon, "DelMonE").Build();
            var providerLearnDelMonF = new ProviderMonitoringBuilder().With(m => m.Occur, "F").With(m => m.Mon, "DelMonF").Build();
            var providerLearnDelMonG = new ProviderMonitoringBuilder().With(m => m.Occur, "G").With(m => m.Mon, "DelMonG").Build();
            var providerLearnDelMonH = new ProviderMonitoringBuilder().With(m => m.Occur, "H").With(m => m.Mon, "DelMonH").Build();

            var providerLearnDelMonitorings = new List <ProviderMonitoring>()
            {
                providerLearnDelMonE,
                providerLearnDelMonF,
                providerLearnDelMonG,
                providerLearnDelMonH,
            };

            var learningDelivery = new LearningDeliveryBuilder().With(ld => ld.ProviderSpecDeliveryMonitorings, providerLearnDelMonitorings).Build();

            var providerMonitorings = NewBuilder().BuildProviderMonitorings(learner, learningDelivery);

            providerMonitorings.LearnerA.Should().BeNull();
            providerMonitorings.LearnerB.Should().BeNull();

            providerMonitorings.LearningDeliveryA.Should().BeNull();
            providerMonitorings.LearningDeliveryB.Should().BeNull();
            providerMonitorings.LearningDeliveryC.Should().BeNull();
            providerMonitorings.LearningDeliveryD.Should().BeNull();
        }
        public void BuildProviderSpecLearnMonitoringsForLearner_NullLearningDelivery()
        {
            var providerLearnerMonA = new ProviderMonitoringBuilder().With(m => m.Occur, "A").With(m => m.Mon, "MonA").Build();
            var providerLearnerMonB = new ProviderMonitoringBuilder().With(m => m.Occur, "B").With(m => m.Mon, "MonB").Build();

            var providerLearnerMonitorings = new List <ProviderMonitoring>()
            {
                providerLearnerMonA,
                providerLearnerMonB,
            };

            var learner = new LearnerBuilder().With(l => l.ProviderSpecLearnMonitorings, providerLearnerMonitorings).Build();

            var providerMonitorings = NewBuilder().BuildProviderMonitorings(learner, null);

            providerMonitorings.LearnerA.Should().Be("MonA");
            providerMonitorings.LearnerB.Should().Be("MonB");

            providerMonitorings.LearningDeliveryA.Should().BeNull();
            providerMonitorings.LearningDeliveryB.Should().BeNull();
            providerMonitorings.LearningDeliveryC.Should().BeNull();
            providerMonitorings.LearningDeliveryD.Should().BeNull();
        }
Beispiel #13
0
        public void PMRAppFinRecordFilter_Test()
        {
            var appFinRecordsPmr = new List <AppFinRecord>()
            {
                new AppFindRecordBuilder().With(a => a.AFinType, "PMR").With(a => a.AFinCode, 1).Build(),
                new AppFindRecordBuilder().With(a => a.AFinType, "PMR").With(a => a.AFinCode, 2).Build()
            };

            var appFinRecordsNonPmr = new List <AppFinRecord>()
            {
                new AppFindRecordBuilder().With(a => a.AFinType, "TNP").With(a => a.AFinCode, 1).With <int>(a => a.AFinAmount, 10).Build(),
            };

            var learningDeliveryOne = new LearningDeliveryBuilder()
                                      .With(ld => ld.LearnRefNumber, "LearningRefNumber1")
                                      .With(ld => ld.FundModel, 36)
                                      .With(a => a.AimSeqNumber, 1)
                                      .With(ld => ld.AppFinRecords, appFinRecordsPmr)
                                      .Build();

            var learningDeliveryTwo = new LearningDeliveryBuilder()
                                      .With(ld => ld.LearnRefNumber, "LearningRefNumber2")
                                      .With(ld => ld.FundModel, 36)
                                      .With(a => a.AimSeqNumber, 2)
                                      .Build();

            var nonPmrlearningDelivery = new LearningDeliveryBuilder()
                                         .With(ld => ld.LearnRefNumber, "LearningRefNumber3")
                                         .With(ld => ld.FundModel, 36)
                                         .With(ld => ld.AppFinRecords, appFinRecordsNonPmr)
                                         .Build();

            var learningDeliveries = new List <LearningDelivery>()
            {
                learningDeliveryOne,
                learningDeliveryTwo,
                nonPmrlearningDelivery
            };

            var nonPmrLearningDeliveries = new List <LearningDelivery>
            {
                nonPmrlearningDelivery
            };

            var learnerOne = new LearnerBuilder()
                             .With(l => l.LearnRefNumber, "LearningRefNumber1")
                             .With(l => l.LearningDeliveries, learningDeliveries)
                             .Build();

            var learnerTwo = new LearnerBuilder()
                             .With(l => l.LearnRefNumber, "LearningRefNumber2")
                             .With(l => l.LearningDeliveries, learningDeliveries)
                             .Build();

            var learnerThree = new LearnerBuilder()
                               .With(l => l.LearnRefNumber, "LearningRefNumber3")
                               .With(l => l.LearningDeliveries, nonPmrLearningDeliveries)
                               .Build();

            var learnerFour = new LearnerBuilder()
                              .With(l => l.LearnRefNumber, "LearningRefNumber4")
                              .Build();

            var learners = new List <Learner>
            {
                learnerOne,
                learnerTwo,
                learnerThree,
                learnerFour
            };

            NewBuilder().PMRAppFinRecordFilter(learners, "LearningRefNumber1").Should().BeTrue();
            NewBuilder().PMRAppFinRecordFilter(learners, "LearningRefNumber2").Should().BeTrue();
            NewBuilder().PMRAppFinRecordFilter(learners, "LearningRefNumber3").Should().BeFalse();
            NewBuilder().PMRAppFinRecordFilter(learners, "LearningRefNumber4").Should().BeFalse();
        }
Beispiel #14
0
        public void GetName_NullName()
        {
            var learner = new LearnerBuilder().With(l => l.FamilyName, null).Build();

            NewBuilder().GetName(learner, l => l.FamilyName).Should().BeNull();
        }
Beispiel #15
0
        public void GetName()
        {
            var learner = new LearnerBuilder().With(l => l.FamilyName, "FamilyName").Build();

            NewBuilder().GetName(learner, l => l.FamilyName).Should().Be("FamilyName");
        }
Beispiel #16
0
        public void GetRelevantLearners_Test()
        {
            var appFinRecordsPmr = new List <AppFinRecord>()
            {
                new AppFindRecordBuilder().With(a => a.AFinType, "PMR").With(a => a.AFinCode, 1).Build(),
                new AppFindRecordBuilder().With(a => a.AFinType, "PMR").With(a => a.AFinCode, 2).Build()
            };

            var appFinRecordsNonPmr = new List <AppFinRecord>()
            {
                new AppFindRecordBuilder().With(a => a.AFinType, "TNP").With(a => a.AFinCode, 1).With <int>(a => a.AFinAmount, 10).Build(),
            };

            var learningDeliveryOne = new LearningDeliveryBuilder()
                                      .With(ld => ld.LearnRefNumber, "LearningRefNumber1")
                                      .With(ld => ld.FundModel, 36)
                                      .With(a => a.AimSeqNumber, 1)
                                      .With(ld => ld.AppFinRecords, appFinRecordsPmr)
                                      .Build();

            var learningDeliveryTwo = new LearningDeliveryBuilder()
                                      .With(ld => ld.LearnRefNumber, "LearningRefNumber2")
                                      .With(ld => ld.FundModel, 36)
                                      .With(a => a.AimSeqNumber, 2)
                                      .Build();

            var nonPmrlearningDelivery = new LearningDeliveryBuilder()
                                         .With(ld => ld.LearnRefNumber, "LearningRefNumber3")
                                         .With(ld => ld.FundModel, 36)
                                         .With(ld => ld.AppFinRecords, appFinRecordsNonPmr)
                                         .Build();

            var learningDeliveries = new List <LearningDelivery>()
            {
                learningDeliveryOne,
                learningDeliveryTwo,
                nonPmrlearningDelivery
            };

            var nonPmrLearningDeliveries = new List <LearningDelivery>
            {
                nonPmrlearningDelivery
            };

            var paymentOne = new PaymentBuilder()
                             .With(p => p.LearnerReferenceNumber, "LearningRefNumber3")
                             .With <byte>(p => p.FundingSource, 3)
                             .With <byte>(p => p.CollectionPeriod, 1).Build();

            var paymentTwo = new PaymentBuilder()
                             .With(p => p.LearnerReferenceNumber, "LearningRefNumber4")
                             .With <byte>(p => p.FundingSource, 3)
                             .With <byte>(p => p.CollectionPeriod, 1).Build();

            var paymentThree = new PaymentBuilder()
                               .With(p => p.LearnerReferenceNumber, "LearningRefNumber5")
                               .With <byte>(p => p.FundingSource, 2)
                               .With <byte>(p => p.CollectionPeriod, 1).Build();

            var payments = new List <Payment>()
            {
                paymentOne,
                paymentTwo,
                paymentThree
            };

            var learnerOne = new LearnerBuilder()
                             .With(l => l.LearnRefNumber, "LearningRefNumber1")
                             .With(l => l.LearningDeliveries, learningDeliveries)
                             .Build();

            var learnerTwo = new LearnerBuilder()
                             .With(l => l.LearnRefNumber, "LearningRefNumber2")
                             .With(l => l.LearningDeliveries, learningDeliveries)
                             .Build();

            var learnerThree = new LearnerBuilder()
                               .With(l => l.LearnRefNumber, "LearningRefNumber3")
                               .With(l => l.LearningDeliveries, nonPmrLearningDeliveries)
                               .Build();

            var learnerFour = new LearnerBuilder()
                              .With(l => l.LearnRefNumber, "LearningRefNumber4")
                              .Build();

            var learnerFive = new LearnerBuilder()
                              .With(l => l.LearnRefNumber, "LearningRefNumber5")
                              .Build();

            var learners = new List <Learner>
            {
                learnerOne,
                learnerTwo,
                learnerThree,
                learnerFour,
                learnerFive
            };

            var relevantLearners = NewBuilder().GetRelevantLearners(learners, payments).ToList();

            relevantLearners.Count().Should().Be(3);
            relevantLearners.Contains(learnerOne.LearnRefNumber).Should().BeTrue();
            relevantLearners.Contains(learnerTwo.LearnRefNumber).Should().BeTrue();
            relevantLearners.Contains(learnerThree.LearnRefNumber).Should().BeTrue();
            relevantLearners.Contains(learnerFour.LearnRefNumber).Should().BeFalse();
            relevantLearners.Contains(learnerFive.LearnRefNumber).Should().BeFalse();
        }
Beispiel #17
0
        private InvalidLearnerData PopulateInvalidLearners(int ukprn, IEnumerable <ILearner> learners, IEnumerable <ILearnerDestinationAndProgression> learnerDestinationAndProgressions)
        {
            var invalidLearnerData = new InvalidLearnerData();

            int learnerId                           = 1;
            int learnerDeliveryId                   = 1;
            int learnerEmploymentStatusId           = 1;
            int learnerEmploymentStatusMonitoringId = 1;
            int learningDeliveryHEId                = 1;
            int learnerDeliveryFamId                = 1;
            int appFinRecordId                      = 1;
            int learningDeliveryWorkPlacementId     = 1;
            int learnerFAMId                        = 1;
            int learnerHEId                         = 1;
            int learnerHEFinancialSupportId         = 1;
            int providerSpecLearnerMonitoringId     = 1;
            int providerSpecDeliveryMonitoringId    = 1;
            int contactPreferenceId                 = 1;
            int lLDDandHealthProblemID              = 1;
            int learnerDestinationandProgressionId  = 1;
            int dPOutcomeId                         = 1;

            learners.NullSafeForEach(learner =>
            {
                invalidLearnerData.RecordsInvalidLearners.Add(LearnerBuilder.BuildInvalidLearner(ukprn, learner, learnerId));

                learner.ContactPreferences.NullSafeForEach(
                    contactPreference =>
                    PopulateContactPreferences(ukprn, learner, contactPreference, learnerId, contactPreferenceId++, invalidLearnerData));

                learner.LearningDeliveries.NullSafeForEach(learningDelivery =>
                {
                    PopulateLearningDelivery(ukprn, learner, learningDelivery, learnerId, learnerDeliveryId, invalidLearnerData);

                    if (learningDelivery.LearningDeliveryHEEntity != null)
                    {
                        PopulateLearningDeliveryHERecord(ukprn, learner, learningDelivery, learningDelivery.LearningDeliveryHEEntity, learningDeliveryHEId++, invalidLearnerData);
                    }

                    learningDelivery.AppFinRecords.NullSafeForEach(
                        appFinRecord =>
                        PopulateLearningDeliveryAppFinRecord(ukprn, learner, learningDelivery, appFinRecord, learnerDeliveryId, appFinRecordId++, invalidLearnerData));

                    learningDelivery.LearningDeliveryFAMs.NullSafeForEach(
                        famRecord =>
                        PopulateLearningDeliveryFAMRecord(ukprn, learner, learningDelivery, famRecord, learnerDeliveryId, learnerDeliveryFamId++, invalidLearnerData));

                    learningDelivery.LearningDeliveryWorkPlacements.NullSafeForEach(workPlacement =>
                                                                                    PopulateLearningDeliveryWorkPlacement(ukprn, learner, learningDelivery, workPlacement, learnerDeliveryId, learningDeliveryWorkPlacementId++, invalidLearnerData));

                    learningDelivery.ProviderSpecDeliveryMonitorings.NullSafeForEach(monitoring =>
                                                                                     PopulateProviderSpecDeliveryMonitoring(ukprn, learner, learningDelivery, monitoring, learnerDeliveryId, providerSpecDeliveryMonitoringId++, invalidLearnerData));

                    learnerDeliveryId++;
                });

                learner.LearnerEmploymentStatuses.NullSafeForEach(employmentStatus =>
                {
                    PopulateLearnerEmploymentStatus(ukprn, learner, employmentStatus, learnerId, learnerEmploymentStatusId, invalidLearnerData);

                    employmentStatus.EmploymentStatusMonitorings?.ToList()
                    .ForEach(monitoring =>
                             PopulateEmploymentStatusMonitoring(ukprn, learner, employmentStatus, monitoring, learnerEmploymentStatusId, learnerEmploymentStatusMonitoringId++, invalidLearnerData));

                    learnerEmploymentStatusId++;
                });

                learner.LearnerFAMs.NullSafeForEach(fam => PopulateLearnerFAM(ukprn, learner, fam, learnerId, learnerFAMId++, invalidLearnerData));

                if (learner.LearnerHEEntity != null)
                {
                    PopulateLearnerHE(ukprn, learner, learnerId, learnerHEId++, invalidLearnerData);

                    learner.LearnerHEEntity.LearnerHEFinancialSupports.NullSafeForEach(support => PopulateLearnerHEFinancialSupport(ukprn, learner, support, learnerHEFinancialSupportId++, invalidLearnerData));
                }

                learner.LLDDAndHealthProblems.NullSafeForEach(problem => PopulateLLDDAndHealthProblem(ukprn, learner, problem, learnerId, lLDDandHealthProblemID++, invalidLearnerData));

                learner.ProviderSpecLearnerMonitorings.NullSafeForEach(monitoring => PopulateProviderSpecLearnerMonitorings(ukprn, learner, monitoring, learnerId, providerSpecLearnerMonitoringId++, invalidLearnerData));

                learnerId++;
            });

            learnerDestinationAndProgressions.NullSafeForEach(learnerDestinationAndProgression =>
            {
                invalidLearnerData.RecordsInvalidLearnerDestinationandProgressions.Add(new EF.Invalid.LearnerDestinationandProgression
                {
                    LearnerDestinationandProgression_Id = learnerDestinationandProgressionId,
                    UKPRN          = ukprn,
                    LearnRefNumber = learnerDestinationAndProgression.LearnRefNumber,
                    ULN            = learnerDestinationAndProgression.ULN
                });

                learnerDestinationAndProgression.DPOutcomes.NullSafeForEach(dpOutcome =>
                {
                    invalidLearnerData.RecordsInvalidDpOutcomes.Add(new EF.Invalid.DPOutcome
                    {
                        DPOutcome_Id = dPOutcomeId,
                        LearnerDestinationandProgression_Id = learnerDestinationandProgressionId,
                        LearnRefNumber = learnerDestinationAndProgression.LearnRefNumber,
                        OutCode        = dpOutcome.OutCode,
                        UKPRN          = ukprn,
                        OutCollDate    = dpOutcome.OutCollDate,
                        OutEndDate     = dpOutcome.OutEndDateNullable,
                        OutStartDate   = dpOutcome.OutStartDate,
                        OutType        = dpOutcome.OutType
                    });

                    dPOutcomeId++;
                });

                learnerDestinationandProgressionId++;
            });

            return(invalidLearnerData);
        }