private PaymentModel ToPaymentModel(
ProviderPayment paymentInfo,
long ukprn,
FundingSourceType fundingSource,
decimal amount,
long jobId,
long?employerAccountId)
{
var learner = testSession.GetLearner(ukprn, paymentInfo.LearnerId);
var standardCode = paymentInfo.StandardCode;
if (!standardCode.HasValue)
{
var aim = learner.Aims.FirstOrDefault(a =>
{
var aimStartDate = a.StartDate.ToDate();
var aimStartPeriod = new CollectionPeriodBuilder().WithDate(aimStartDate).Build();
var aimDuration = string.IsNullOrEmpty(a.ActualDuration) ? a.PlannedDuration : a.ActualDuration;
var aimEndPeriod = AimPeriodMatcher.GetEndPeriodForAim(aimStartPeriod, aimDuration);
var aimFinishedInPreviousPeriod = aimEndPeriod.FinishesBefore(currentCollectionPeriod);
if (!aimFinishedInPreviousPeriod)
{
return(true);
}
if (a.CompletionStatus == CompletionStatus.Withdrawn && amount >= 0M)
{
return(false);
}
return(a.AimReference == "ZPROG001" && (a.CompletionStatus == CompletionStatus.Completed || a.CompletionStatus == CompletionStatus.Withdrawn));
});
standardCode = aim?.StandardCode ?? 0;
}
return(new PaymentModel
{
CollectionPeriod = new CollectionPeriodBuilder().WithSpecDate(paymentInfo.CollectionPeriod).Build(),
Ukprn = ukprn,
DeliveryPeriod = new DeliveryPeriodBuilder().WithSpecDate(paymentInfo.DeliveryPeriod).Build(),
TransactionType = paymentInfo.TransactionType,
ContractType = contractType,
Amount = amount,
FundingSource = fundingSource,
LearnerReferenceNumber = learner.LearnRefNumber,
JobId = jobId,
AccountId = employerAccountId,
LearningAimStandardCode = standardCode.Value
});
}
private async Task RefreshTestSessionLearnerFromIlr(string ilrFile, IEnumerable <Learner> learners)
{
XNamespace xsdns = tdgService.IlrNamespace;
var xDoc = XDocument.Parse(ilrFile);
var learnerDescendants = xDoc.Descendants(xsdns + "Learner");
var learnersEnumeration = learners as Learner[] ?? learners.ToArray();
for (var i = 0; i < learnersEnumeration.Count(); i++)
{
var request = learnersEnumeration.Skip(i).Take(1).First();
var testSessionLearner = testSession.GetLearner(testSession.Provider.Ukprn, request.LearnerIdentifier);
var originalUln = testSessionLearner.Uln;
var learner = learnerDescendants.Skip(i).Take(1).First();
testSessionLearner.LearnRefNumber = learner.Elements(xsdns + "LearnRefNumber").First().Value;
testSessionLearner.Uln = long.Parse(learner.Elements(xsdns + "ULN").First().Value);
await UpdatePaymentHistoryTables(testSessionLearner.Ukprn, originalUln, testSessionLearner.Uln,
testSessionLearner.LearnRefNumber);
}
}
protected override IList <PayableEarningEvent> GetExpectedEvents()
{
var result = new List <PayableEarningEvent>();
var learnerIds = earningSpecs.Select(e => e.LearnerId).Distinct().ToList();
foreach (var learnerId in learnerIds)
{
var learnerSpec = testSession.GetLearner(provider.Ukprn, learnerId);
var fm36Learner = learnerSpecs.Single(l => l.LearnRefNumber == learnerSpec.LearnRefNumber);
var learner = new Learner
{
ReferenceNumber = learnerSpec.LearnRefNumber,
Uln = learnerSpec.Uln
};
if (learnerSpec.Aims.Count == 0)
{
learnerSpec.Aims.Add(new Aim
{
LearnerId = learnerSpec.LearnerIdentifier,
ProgrammeType = learnerSpec.Course.ProgrammeType,
FrameworkCode = learnerSpec.Course.FrameworkCode,
PathwayCode = learnerSpec.Course.PathwayCode,
StandardCode = learnerSpec.Course.StandardCode,
FundingLineType = learnerSpec.Course.FundingLineType,
AimReference = learnerSpec.Course.LearnAimRef
});
}
foreach (var aimSpec in learnerSpec.Aims.Where(a => AimPeriodMatcher.IsStartDateValidForCollectionPeriod(a.StartDate, collectionPeriod,
a.PlannedDurationAsTimespan, a.ActualDurationAsTimespan, a.CompletionStatus, a.AimReference, a.PlannedDuration, a.ActualDuration)))
{
var learningAim = new LearningAim
{
ProgrammeType = aimSpec.ProgrammeType,
FrameworkCode = aimSpec.FrameworkCode,
PathwayCode = aimSpec.PathwayCode,
StandardCode = aimSpec.StandardCode,
FundingLineType = aimSpec.FundingLineType,
Reference = aimSpec.AimReference
};
var aimEarningSpecs = earningSpecs.Where(e => e.LearnerId == learnerId && e.AimSequenceNumber.GetValueOrDefault(aimSpec.AimSequenceNumber) == aimSpec.AimSequenceNumber).ToList();
var fullListOfTransactionTypes = aimEarningSpecs.SelectMany(p => p.Values.Keys).Distinct().ToList();
var onProgEarnings = fullListOfTransactionTypes.Where(EnumHelper.IsOnProgType).ToList();
var incentiveEarnings = fullListOfTransactionTypes.Where(type => EnumHelper.IsIncentiveType(type, aimSpec.IsMainAim)).ToList();
if (aimSpec.AimReference == "ZPROG001" && onProgEarnings.Any())
{
var onProgEarning = new PayableEarningEvent
{
CollectionPeriod = collectionPeriod,
Ukprn = provider.Ukprn,
OnProgrammeEarnings = onProgEarnings.Select(tt => new OnProgrammeEarning
{
Type = (OnProgrammeEarningType)(int)tt,
Periods = aimEarningSpecs.Select(e => new EarningPeriod
{
Amount = e.Values[tt],
Period = e.DeliveryCalendarPeriod,
PriceEpisodeIdentifier = FindPriceEpisodeIdentifier(e.Values[tt], e, fm36Learner, tt)
}).ToList().AsReadOnly()
}).ToList(),
JobId = provider.JobId,
Learner = learner,
LearningAim = learningAim
};
result.Add(onProgEarning);
}
if (incentiveEarnings.Any())
{
var incentiveEarning = new PayableEarningEvent
{
CollectionPeriod = collectionPeriod,
Ukprn = provider.Ukprn,
IncentiveEarnings = incentiveEarnings.Select(tt => new IncentiveEarning
{
Type = (IncentiveEarningType)(int)tt,
Periods = aimEarningSpecs.Select(e => new EarningPeriod
{
Amount = e.Values[tt],
Period = e.DeliveryCalendarPeriod,
PriceEpisodeIdentifier = FindPriceEpisodeIdentifier(e.Values[tt], e, fm36Learner, tt)
}).ToList().AsReadOnly()
}).ToList(),
JobId = provider.JobId,
Learner = learner,
LearningAim = learningAim
};
result.Add(incentiveEarning);
}
}
}
return(result);
}
public static ApprenticeshipModel CreateApprenticeshipModel(Apprenticeship apprenticeshipSpec, TestSession testSession)
{
if (apprenticeshipSpec.ApprenticeshipId == default(long))
{
apprenticeshipSpec.ApprenticeshipId = testSession.GenerateId();
}
if (apprenticeshipSpec.Ukprn == default(long))
{
if (string.IsNullOrWhiteSpace(apprenticeshipSpec.Provider))
{
apprenticeshipSpec.Ukprn = testSession.Ukprn;
}
else
{
apprenticeshipSpec.Ukprn = testSession.GetProviderByIdentifier(apprenticeshipSpec.Provider).Ukprn;
}
}
var employer = testSession.GetEmployer(apprenticeshipSpec.Employer);
if (apprenticeshipSpec.AccountId == default(long))
{
apprenticeshipSpec.AccountId = employer.AccountId;
}
if (!string.IsNullOrEmpty(apprenticeshipSpec.SendingEmployer) && !apprenticeshipSpec.SenderAccountId.HasValue)
{
apprenticeshipSpec.SenderAccountId = testSession.GetEmployer(apprenticeshipSpec.SendingEmployer).AccountId;
}
if (apprenticeshipSpec.Uln == default(long))
{
var learnerId = string.IsNullOrWhiteSpace(apprenticeshipSpec.Identifier)
? testSession.Learner.LearnerIdentifier
: apprenticeshipSpec.LearnerId;
apprenticeshipSpec.Uln = testSession.GetLearner(apprenticeshipSpec.Ukprn, learnerId).Uln;
}
var apprenticeshipModel = new ApprenticeshipModel
{
Id = apprenticeshipSpec.ApprenticeshipId,
Ukprn = apprenticeshipSpec.Ukprn,
AccountId = apprenticeshipSpec.AccountId,
TransferSendingEmployerAccountId = apprenticeshipSpec.SenderAccountId,
Uln = apprenticeshipSpec.Uln,
FrameworkCode = apprenticeshipSpec.FrameworkCode ?? 0, //TODO change when app bug is fixed
ProgrammeType = apprenticeshipSpec.ProgrammeType ?? 0,
PathwayCode = apprenticeshipSpec.PathwayCode ?? 0,
StandardCode = apprenticeshipSpec.StandardCode ?? 0,
Priority = apprenticeshipSpec.Priority,
Status = apprenticeshipSpec.Status.ToApprenticeshipPaymentStatus(),
LegalEntityName = "Test SFA",
EstimatedStartDate = apprenticeshipSpec.StartDate.ToDate(),
EstimatedEndDate = apprenticeshipSpec.EndDate.ToDate(),
AgreedOnDate = string.IsNullOrWhiteSpace(apprenticeshipSpec.AgreedOnDate) ?
DateTime.UtcNow :
apprenticeshipSpec.AgreedOnDate.ToDate(),
StopDate = string.IsNullOrWhiteSpace(apprenticeshipSpec.StopEffectiveFrom) ?
default(DateTime?) :
apprenticeshipSpec.StopEffectiveFrom.ToDate(),
IsLevyPayer = employer.IsLevyPayer,
ApprenticeshipEmployerType = GetApprenticeshipEmployerType(apprenticeshipSpec.EmployerType)
};
return(apprenticeshipModel);
}
protected override IList <EarningEvent> GetExpectedEvents()
{
var result = new List <EarningEvent>();
var learnerIds = earningSpecs.Where(e => e.Ukprn == provider.Ukprn).Select(e => e.LearnerId).Distinct().ToList();
foreach (var learnerId in learnerIds)
{
var learnerSpec = testSession.GetLearner(provider.Ukprn, learnerId);
var fm36Learner = learnerSpecs.Single(l => l.LearnRefNumber == learnerSpec.LearnRefNumber);
var learner = new Learner
{
ReferenceNumber = learnerSpec.LearnRefNumber,
Uln = learnerSpec.Uln
};
if (learnerSpec.Aims.Count == 0)
{
learnerSpec.Aims.Add(new Aim
{
LearnerId = learnerSpec.LearnerIdentifier,
ProgrammeType = learnerSpec.Course.ProgrammeType,
FrameworkCode = learnerSpec.Course.FrameworkCode,
PathwayCode = learnerSpec.Course.PathwayCode,
StandardCode = learnerSpec.Course.StandardCode,
FundingLineType = learnerSpec.Course.FundingLineType,
AimReference = learnerSpec.Course.LearnAimRef
});
}
IEnumerable <Aim> currentAims;
// AimPeriodMatcher doesn't support completed aims from the past, this is a workaround until imminent refactoring
if (learnerSpec.Aims.Count == 1)
{
currentAims = learnerSpec.Aims;
}
else
{
currentAims = learnerSpec.Aims.Where(a => AimPeriodMatcher.IsStartDateValidForCollectionPeriod(a.StartDate, collectionPeriod,
a.PlannedDurationAsTimespan, a.ActualDurationAsTimespan, a.CompletionStatus, a.AimReference, a.PlannedDuration, a.ActualDuration));
}
foreach (var aimSpec in currentAims)
{
var learningAim = new LearningAim
{
ProgrammeType = aimSpec.ProgrammeType,
FrameworkCode = aimSpec.FrameworkCode,
PathwayCode = aimSpec.PathwayCode,
StandardCode = aimSpec.StandardCode,
Reference = aimSpec.AimReference
};
var aimEarningSpecs = earningSpecs.Where(e => e.LearnerId == learnerId && e.AimSequenceNumber.GetValueOrDefault(aimSpec.AimSequenceNumber) == aimSpec.AimSequenceNumber).ToList();
var fullListOfTransactionTypes = aimEarningSpecs.SelectMany(p => p.Values.Keys).Distinct().ToList();
var onProgEarnings = fullListOfTransactionTypes.Where(EnumHelper.IsOnProgType).ToList();
var functionalSkillEarnings = fullListOfTransactionTypes.Where(t => EnumHelper.IsFunctionalSkillType(t, aimSpec.IsMainAim)).ToList();
var incentiveEarnings = fullListOfTransactionTypes.Where(t => EnumHelper.IsIncentiveType(t, aimSpec.IsMainAim)).ToList();
if (aimSpec.IsMainAim && onProgEarnings.Any())
{
var contractTypeEarningsEvents = CreateContractTypeEarningsEventEarningEvent(provider.Ukprn);
foreach (var onProgEarning in contractTypeEarningsEvents)
{
onProgEarning.OnProgrammeEarnings = onProgEarnings.Select(tt => new OnProgrammeEarning
{
Type = (OnProgrammeEarningType)(int)tt,
Periods = GetEarningPeriods(aimEarningSpecs, aimSpec, onProgEarning, tt, fm36Learner).AsReadOnly()
}).ToList();
onProgEarning.JobId = provider.JobId;
onProgEarning.Learner = learner;
onProgEarning.LearningAim = learningAim;
result.Add(onProgEarning);
}
}
if (!aimSpec.IsMainAim && functionalSkillEarnings.Any())
{
var functionalSkillEarningsEvents = CreateFunctionalSkillEarningEvents(functionalSkillEarnings,
aimEarningSpecs,
fm36Learner,
learner,
learningAim,
aimSpec);
result.AddRange(functionalSkillEarningsEvents);
}
if (!aimSpec.IsMainAim && incentiveEarnings.Any())
{
var contractTypeIncentiveEarnings = CreateContractTypeEarningsEventEarningEvent(provider.Ukprn);
foreach (var incentiveEarning in contractTypeIncentiveEarnings)
{
incentiveEarning.IncentiveEarnings = incentiveEarnings.Select(tt => new IncentiveEarning
{
Type = (IncentiveEarningType)(int)tt,
Periods = GetEarningPeriods(aimEarningSpecs, aimSpec, incentiveEarning, tt, fm36Learner).AsReadOnly(),
}).ToList();
incentiveEarning.JobId = provider.JobId;
incentiveEarning.Learner = learner;
incentiveEarning.LearningAim = learningAim;
result.Add(incentiveEarning);
}
}
}
}
return(result);
}
public void TheProviderChangesTheLearnersUln(long newUln)
{
TestSession.GetLearner(TestSession.Provider.Ukprn, null).Uln = newUln;
CurrentIlr = PreviousIlr;
CurrentIlr.ForEach(x => x.Uln = newUln);
}
protected override IList <ProviderPaymentEvent> GetExpectedEvents()
{
var expectedPayments = new List <ProviderPaymentEvent>();
var payments = paymentSpec.Where(p => p.ParsedCollectionPeriod.Period == collectionPeriod.Period &&
p.ParsedCollectionPeriod.AcademicYear == collectionPeriod.AcademicYear);
foreach (var providerPayment in payments)
{
var eventCollectionPeriod = new CollectionPeriodBuilder().WithSpecDate(providerPayment.CollectionPeriod).Build();
var deliveryPeriod = new DeliveryPeriodBuilder().WithSpecDate(providerPayment.DeliveryPeriod).Build();
var testLearner = testSession.GetLearner(provider.Ukprn, providerPayment.LearnerId);
var learner = new Learner
{
ReferenceNumber = testLearner.LearnRefNumber,
Uln = testLearner.Uln,
};
var standardCode = providerPayment.StandardCode;
if (!standardCode.HasValue)
{
var aim = testLearner.Aims.FirstOrDefault(a =>
{
var aimStartDate = a.StartDate.ToDate();
var aimStartPeriod = new CollectionPeriodBuilder().WithDate(aimStartDate).Build();
var aimDuration = string.IsNullOrEmpty(a.ActualDuration) ? a.PlannedDuration : a.ActualDuration;
var aimEndPeriod = AimPeriodMatcher.GetEndPeriodForAim(aimStartPeriod, aimDuration);
var aimFinishedInPreviousPeriod = aimEndPeriod.FinishesBefore(collectionPeriod);
if (!aimFinishedInPreviousPeriod)
{
return(true);
}
// withdrawal but payments made during period active
if (a.CompletionStatus == CompletionStatus.Withdrawn &&
providerPayment.LevyPayments >= 0M &&
providerPayment.SfaCoFundedPayments >= 0M &&
providerPayment.EmployerCoFundedPayments >= 0M &&
providerPayment.SfaFullyFundedPayments >= 0M)
{
return(false);
}
// retrospective withdrawal
return(a.AimReference == "ZPROG001" && (a.CompletionStatus == CompletionStatus.Completed || a.CompletionStatus == CompletionStatus.Withdrawn));
});
standardCode = aim?.StandardCode ?? 0;
}
if (providerPayment.SfaCoFundedPayments != 0)
{
var coFundedSfa = new SfaCoInvestedProviderPaymentEvent
{
TransactionType = providerPayment.TransactionType,
AmountDue = providerPayment.SfaCoFundedPayments,
CollectionPeriod = eventCollectionPeriod,
DeliveryPeriod = deliveryPeriod,
Learner = learner,
FundingSourceType = FundingSourceType.CoInvestedSfa,
LearningAim = new LearningAim {
StandardCode = standardCode.Value
},
AccountId = providerPayment.AccountId
};
expectedPayments.Add(coFundedSfa);
}
if (providerPayment.EmployerCoFundedPayments != 0)
{
var coFundedEmp = new EmployerCoInvestedProviderPaymentEvent
{
TransactionType = providerPayment.TransactionType,
AmountDue = providerPayment.EmployerCoFundedPayments,
CollectionPeriod = eventCollectionPeriod,
DeliveryPeriod = deliveryPeriod,
Learner = learner,
FundingSourceType = FundingSourceType.CoInvestedEmployer,
AccountId = providerPayment.AccountId,
LearningAim = new LearningAim {
StandardCode = standardCode.Value
}
};
expectedPayments.Add(coFundedEmp);
}
if (providerPayment.SfaFullyFundedPayments != 0)
{
var fullyFundedSfa = new SfaFullyFundedProviderPaymentEvent
{
TransactionType = providerPayment.TransactionType,
AmountDue = providerPayment.SfaFullyFundedPayments,
CollectionPeriod = eventCollectionPeriod,
DeliveryPeriod = deliveryPeriod,
Learner = learner,
AccountId = providerPayment.AccountId,
LearningAim = new LearningAim {
StandardCode = standardCode.Value
}
};
expectedPayments.Add(fullyFundedSfa);
}
if (providerPayment.LevyPayments != 0)
{
var levyFunded = new LevyProviderPaymentEvent
{
TransactionType = providerPayment.TransactionType,
AmountDue = providerPayment.LevyPayments,
CollectionPeriod = eventCollectionPeriod,
DeliveryPeriod = deliveryPeriod,
Learner = learner,
AccountId = providerPayment.AccountId,
LearningAim = new LearningAim {
StandardCode = standardCode.Value
}
};
expectedPayments.Add(levyFunded);
}
if (providerPayment.TransferPayments != 0)
{
var transferFunded = new TransferProviderPaymentEvent
{
TransactionType = providerPayment.TransactionType,
AmountDue = providerPayment.TransferPayments,
CollectionPeriod = eventCollectionPeriod,
DeliveryPeriod = deliveryPeriod,
Learner = learner,
AccountId = providerPayment.AccountId,
LearningAim = new LearningAim {
StandardCode = standardCode.Value
}
};
expectedPayments.Add(transferFunded);
}
}
return(expectedPayments);
}
protected override IList <EarningFailedDataLockMatching> GetExpectedEvents()
{
var earningFailedDataLockEvents = new List <EarningFailedDataLockMatching>();
var learnerIds = expectedDataLockErrorsSpec.Select(e => e.LearnerId).Distinct().ToList();
foreach (var learnerId in learnerIds)
{
var learner = testSession.GetLearner(provider.Ukprn, learnerId);
var learnerEarnings = expectedDataLockErrorsSpec.Where(x => x.LearnerId == learnerId).ToList();
var groupedEarningPerTransactionTypes = learnerEarnings.GroupBy(x => x.TransactionType);
var earningFailedDataLockEvent = new EarningFailedDataLockMatching
{
CollectionPeriod = collectionPeriod,
Ukprn = provider.Ukprn,
Learner = new Model.Core.Learner
{
Uln = learner.Uln,
},
LearningAim = new LearningAim
{
ProgrammeType = learnerEarnings.First().ProgrammeType, //May need to move to another Matcher
StandardCode = learnerEarnings.First().StandardCode,
FrameworkCode = learnerEarnings.First().FrameworkCode,
PathwayCode = learnerEarnings.First().PathwayCode
},
OnProgrammeEarnings = new List <OnProgrammeEarning>()
};
foreach (var earningPerTransactionTypes in groupedEarningPerTransactionTypes)
{
var groupedEarningPerPeriods = earningPerTransactionTypes.GroupBy(x => x.DeliveryPeriod);
var earningPeriods = new List <EarningPeriod>();
foreach (var earningPerPeriods in groupedEarningPerPeriods)
{
var period = new CollectionPeriodBuilder().WithDate(earningPerPeriods.Key.ToDate()).Build().Period;
if (period > collectionPeriod.Period)
{
continue;
}
earningPeriods.Add(new EarningPeriod
{
PriceEpisodeIdentifier = earningPerPeriods.First().PriceEpisodeIdentifier,
Period = period,
DataLockFailures = earningPerPeriods.Select(x => new DataLockFailure
{
ApprenticeshipId = learnerEarnings.First().ApprenticeshipId,
DataLockError = x.ErrorCode,
ApprenticeshipPriceEpisodeIds = new List <long>()
}).ToList()
});
}
if (EnumHelper.IsOnProgType(earningPerTransactionTypes.Key))
{
earningFailedDataLockEvent.OnProgrammeEarnings.Add(new OnProgrammeEarning
{
Type = (OnProgrammeEarningType)earningPerTransactionTypes.Key,
Periods = earningPeriods.AsReadOnly()
});
}
if (EnumHelper.IsIncentiveType(earningPerTransactionTypes.Key, true))
{
earningFailedDataLockEvent.IncentiveEarnings.Add(new IncentiveEarning
{
Type = (IncentiveEarningType)earningPerTransactionTypes.Key,
Periods = earningPeriods.AsReadOnly()
});
}
}
earningFailedDataLockEvents.Add(earningFailedDataLockEvent);
}
return(earningFailedDataLockEvents);
}
