public override void AssertBreakdown(EarningsAndPaymentsBreakdown breakdown, IEnumerable <LearnerResults> submissionResults, EmployerAccountContext employerAccountContext)
{
var payments = GetPaymentsForBreakdown(breakdown, submissionResults)
.Where(p => p.FundingSource == FundingSource.Levy &&
p.ContractType == ContractType.ContractWithEmployer && p.Amount <= 0)
.ToArray();
foreach (var period in breakdown.EmployersLevyAccountCredited)
{
var employerPayments = payments.Where(p => p.EmployerAccountId == period.EmployerAccountId).ToList();
var positivePayments = employerPayments.Select(x =>
new PaymentResult
{
Amount = x.Amount * -1,
CalculationPeriod = x.CalculationPeriod,
ContractType = x.ContractType,
DeliveryPeriod = x.DeliveryPeriod,
EmployerAccountId = x.EmployerAccountId,
FundingSource = x.FundingSource,
TransactionType = x.TransactionType
});
var prevPeriod = new EmployerAccountPeriodValue
{
EmployerAccountId = period.EmployerAccountId,
PeriodName = period.PeriodName.ToPeriodDateTime().AddMonths(-1).ToPeriodName(),
Value = period.Value
};
AssertResultsForPeriod(prevPeriod, positivePayments.ToArray());
}
}
public override void AssertBreakdown(EarningsAndPaymentsBreakdown breakdown, IEnumerable <LearnerResults> submissionResults, EmployerAccountContext employerAccountContext)
{
var allEarnings = GetEarningsForBreakdown(breakdown, submissionResults);
foreach (var period in breakdown.ProviderEarnedTotal)
{
AssertResultsForPeriod(period, allEarnings);
}
}
protected PaymentResult[] GetPaymentsForBreakdown(EarningsAndPaymentsBreakdown breakdown, IEnumerable <LearnerResults> submissionResults)
{
var payments = submissionResults.Where(r => r.ProviderId.Equals(breakdown.ProviderId, StringComparison.CurrentCultureIgnoreCase));
if (breakdown is LearnerEarningsAndPaymentsBreakdown)
{
payments = payments.Where(r => r.LearnerReferenceNumber.Equals(((LearnerEarningsAndPaymentsBreakdown)breakdown).LearnerReferenceNumber, StringComparison.CurrentCultureIgnoreCase));
}
return(payments.SelectMany(r => r.Payments).ToArray());
}
internal static void ParseEarningsAndPaymentsTableIntoContext(EarningsAndPaymentsBreakdown breakdown, Table earningAndPayments)
{
if (earningAndPayments.Rows.Count < 1)
{
throw new ArgumentException("Earnings and payments table must have at least 1 row");
}
var periodNames = ParseEarningAndPaymentsHeaders(earningAndPayments);
ParseEarningAndPaymentsRows(breakdown, earningAndPayments, periodNames);
}
public override void AssertBreakdown(EarningsAndPaymentsBreakdown breakdown, IEnumerable <LearnerResults> submissionResults, EmployerAccountContext employerAccountContext)
{
var payments = GetPaymentsForBreakdown(breakdown, submissionResults)
.Where(p => p.FundingSource == FundingSource.Levy)
.ToArray();
foreach (var period in breakdown.SfaLevyBudget)
{
AssertResultsForPeriod(period, payments);
}
}
public override void AssertBreakdown(EarningsAndPaymentsBreakdown breakdown, IEnumerable <LearnerResults> submissionResults, EmployerAccountContext employerAccountContext)
{
var payments = GetPaymentsForBreakdown(breakdown, submissionResults)
.Where(p => p.FundingSource == FundingSource.FullyFundedSfa && p.ContractType == ContractType.ContractWithSfa)
.ToArray();
foreach (var period in breakdown.SfaNonLevyAdditionalPayments)
{
AssertResultsForPeriod(period, payments);
}
}
public override void AssertBreakdown(EarningsAndPaymentsBreakdown breakdown, IEnumerable <LearnerResults> submissionResults, EmployerAccountContext employerAccountContext)
{
var payments = submissionResults.SelectMany(r => r.Payments)
.Where(r => r.FundingSource == FundingSource.Levy &&
r.ContractType == ContractType.ContractWithEmployer);
foreach (var period in breakdown.EmployerLevyTransactions)
{
var employerPayments = payments.Where(p => p.EmployerAccountId == period.EmployerAccountId).ToList();
AssertResultsForPeriod(period, employerPayments.ToArray());
}
}
public void ThenTheEmployerSLevyBalanceIs(Table table)
{
var periodBalances = LevyBalanceTableParser.ParseLevyAccountBalanceTable(table, Defaults.EmployerAccountId);
var breakdown = new EarningsAndPaymentsBreakdown
{
EmployerLevyTransactions = periodBalances
};
EarningsAndPaymentsContext.OverallEarningsAndPayments.Add(breakdown);
PaymentsAndEarningsAssertions.AssertPaymentsAndEarningsResults(EarningsAndPaymentsContext, SubmissionContext, EmployerAccountContext);
}
public override void AssertBreakdown(EarningsAndPaymentsBreakdown breakdown, IEnumerable <LearnerResults> submissionResults, EmployerAccountContext employerAccountContext)
{
var allPayments = GetPaymentsForBreakdown(breakdown, submissionResults)
.Where(p => p.FundingSource != FundingSource.CoInvestedEmployer && p.Amount > 0)
.ToArray();
foreach (var period in breakdown.ProviderPaidBySfa)
{
var prevPeriod = new PeriodValue
{
PeriodName = period.PeriodName.ToPeriodDateTime().AddMonths(-1).ToPeriodName(),
Value = period.Value
};
AssertResultsForPeriod(prevPeriod, allPayments);
}
}
public override void AssertBreakdown(EarningsAndPaymentsBreakdown breakdown, IEnumerable <LearnerResults> submissionResults, EmployerAccountContext employerAccountContext)
{
var payments = GetPaymentsForBreakdown(breakdown, submissionResults)
.Where(p => p.FundingSource == FundingSource.Levy && p.ContractType == ContractType.ContractWithEmployer && p.Amount >= 0)
.ToArray();
foreach (var period in breakdown.EmployersLevyAccountDebited)
{
var employerPayments = payments.Where(p => p.EmployerAccountId == period.EmployerAccountId).ToArray();
var prevPeriod = new EmployerAccountPeriodValue
{
EmployerAccountId = period.EmployerAccountId,
PeriodName = period.PeriodName.ToPeriodDateTime().AddMonths(-1).ToPeriodName(),
Value = period.Value
};
AssertResultsForPeriod(prevPeriod, employerPayments);
}
}
private LearnerEarningsResult[] GetEarningsForBreakdown(EarningsAndPaymentsBreakdown breakdown, IEnumerable <LearnerResults> submissionResults)
{
var filteredResults = submissionResults.Where(r => r.ProviderId.Equals(breakdown.ProviderId, StringComparison.CurrentCultureIgnoreCase));
if (breakdown is LearnerEarningsAndPaymentsBreakdown)
{
filteredResults = filteredResults.Where(r => r.LearnerId.Equals(((LearnerEarningsAndPaymentsBreakdown)breakdown).LearnerId, StringComparison.CurrentCultureIgnoreCase));
}
return(filteredResults.Select(r => r.Earnings.Select(e => new LearnerEarningsResult
{
LearnerId = r.LearnerId,
DeliveryPeriod = e.DeliveryPeriod,
CalculationPeriod = e.CalculationPeriod,
Value = e.Value
})).SelectMany(e => e)
.OrderBy(e => e.DeliveryPeriod)
.ThenBy(e => e.LearnerId)
.ToArray());
}
public override void AssertBreakdown(EarningsAndPaymentsBreakdown breakdown, IEnumerable <LearnerResults> submissionResults, EmployerAccountContext employerAccountContext)
{
var allPayments = GetPaymentsForBreakdown(breakdown, submissionResults)
.Where(p => p.FundingSource == FundingSource.CoInvestedEmployer)
.ToArray();
foreach (var period in breakdown.PaymentDueFromEmployers)
{
// Currently have to assume there is only 1 non-levy employer in spec as there is no way to tell employer if there is no commitment.
var employerAccount = employerAccountContext.EmployerAccounts.SingleOrDefault(a => a.Id == period.EmployerAccountId);
var isDasEmployer = employerAccount == null ? false : employerAccount.IsDasEmployer;
var paymentsForEmployer = allPayments.Where(p => p.EmployerAccountId == period.EmployerAccountId || (!isDasEmployer && p.EmployerAccountId == 0)).ToArray();
var prevPeriod = new EmployerAccountPeriodValue
{
EmployerAccountId = period.EmployerAccountId,
PeriodName = period.PeriodName.ToPeriodDateTime().AddMonths(-1).ToPeriodName(),
Value = period.Value
};
AssertResultsForPeriod(prevPeriod, paymentsForEmployer);
}
}
public void ThenProviderEarningAndPaymentsBreakDownTo(string providerIdSuffix, Table earningAndPayments)
{
if (!SubmissionContext.HaveSubmissionsBeenDone)
{
SubmissionContext.SubmissionResults = SubmissionManager.SubmitIlrAndRunMonthEndAndCollateResults(SubmissionContext.IlrLearnerDetails, SubmissionContext.FirstSubmissionDate,
LookupContext, EmployerAccountContext.EmployerAccounts, SubmissionContext.ContractTypes, SubmissionContext.EmploymentStatus, SubmissionContext.LearningSupportStatus);
SubmissionContext.HaveSubmissionsBeenDone = true;
}
var providerBreakdown = EarningsAndPaymentsContext.OverallEarningsAndPayments.SingleOrDefault(x => x.ProviderId == "provider " + providerIdSuffix);
if (providerBreakdown == null)
{
providerBreakdown = new EarningsAndPaymentsBreakdown {
ProviderId = "provider " + providerIdSuffix
};
EarningsAndPaymentsContext.OverallEarningsAndPayments.Add(providerBreakdown);
}
EarningAndPaymentTableParser.ParseEarningsAndPaymentsTableIntoContext(providerBreakdown, earningAndPayments);
AssertResults();
}
public void GivenTheFollowingEarningsAndPaymentsHaveBeenMadeToTheProviderForLearner(string learnerName, Table table)
{
var learnerBreakdown = new EarningsAndPaymentsBreakdown {
ProviderId = "provider " + Defaults.ProviderIdSuffix
};
EarningAndPaymentTableParser.ParseEarningsAndPaymentsTableIntoContext(learnerBreakdown, table);
var learner = LookupContext.AddOrGetUln(learnerName);
var provider = LookupContext.AddOrGetUkprn(learnerBreakdown.ProviderId);
var commitment = CommitmentsContext.Commitments.FirstOrDefault();
foreach (var earned in learnerBreakdown.ProviderEarnedTotal)
{
var requiredPaymentId = Guid.NewGuid().ToString();
var month = int.Parse(earned.PeriodName.Substring(0, 2));
var year = int.Parse(earned.PeriodName.Substring(3, 2)) + 2000;
var date = new DateTime(year, month, 1);
var periodNumber = date.GetPeriodNumber();
var periodName = $"1718-R" + periodNumber.ToString("00");
if (earned.Value > 0)
{
PaymentsManager.SavePaymentDue(requiredPaymentId, provider, learner, null, null, null, Defaults.StandardCode,
commitment, learnerName, periodName,
month, year,
(int)TransactionType.OnProgram,
commitment == null ? ContractType.ContractWithSfa : ContractType.ContractWithEmployer,
earned.Value);
var levyPayment = learnerBreakdown.SfaLevyBudget.Where(x => x.PeriodName == earned.PeriodName).SingleOrDefault();
if (levyPayment != null && levyPayment.Value > 0)
{
PaymentsManager.SavePayment(requiredPaymentId, periodName, month, year,
(int)TransactionType.OnProgram, FundingSource.Levy, levyPayment.Value);
}
var earnedFromEmployer = learnerBreakdown.ProviderEarnedFromEmployers.Where(x => x.PeriodName == earned.PeriodName).SingleOrDefault();
if (earnedFromEmployer != null && earnedFromEmployer.Value > 0)
{
PaymentsManager.SavePayment(requiredPaymentId, periodName, month, year,
(int)TransactionType.OnProgram, FundingSource.CoInvestedEmployer, earnedFromEmployer.Value);
}
var coInvestedBySfaLevy = learnerBreakdown.SfaLevyCoFundBudget.Where(x => x.PeriodName == earned.PeriodName).SingleOrDefault();
if (coInvestedBySfaLevy != null && coInvestedBySfaLevy.Value > 0)
{
PaymentsManager.SavePayment(requiredPaymentId, periodName, month, year,
(int)TransactionType.OnProgram, FundingSource.CoInvestedSfa, coInvestedBySfaLevy.Value);
}
var coInvestedBySfaNonLevy = learnerBreakdown.SfaNonLevyCoFundBudget.Where(x => x.PeriodName == earned.PeriodName).SingleOrDefault();
if (coInvestedBySfaNonLevy != null && coInvestedBySfaNonLevy.Value > 0)
{
PaymentsManager.SavePayment(requiredPaymentId, periodName, month, year,
(int)TransactionType.OnProgram, FundingSource.CoInvestedSfa, coInvestedBySfaNonLevy.Value);
}
}
}
}
private void CreatePreviousEarningsAndPayments(string providerName, string learnerRefererenceNumber, Table table, AimType paymentsAimType)
{
var learnerBreakdown = new EarningsAndPaymentsBreakdown {
ProviderId = providerName
};
EarningAndPaymentTableParser.ParseEarningsAndPaymentsTableIntoContext(learnerBreakdown, table);
var learningDetails = SubmissionContext.HistoricalLearningDetails.Where(x => x.AimType == paymentsAimType && x.LearnerReference.Equals(learnerRefererenceNumber, StringComparison.InvariantCultureIgnoreCase)).Single();
long learnerUln;
if (!string.IsNullOrEmpty(learningDetails.Uln))
{
learnerUln = long.Parse(learningDetails.Uln);
LookupContext.AddUln(learnerRefererenceNumber, learnerUln);
}
else
{
learnerUln = LookupContext.AddOrGetUln(learnerRefererenceNumber);
}
var provider = LookupContext.AddOrGetUkprn(learnerBreakdown.ProviderId);
var commitment = CommitmentsContext.Commitments.FirstOrDefault(x => x.ProviderId == learnerBreakdown.ProviderId && x.LearnerId == learnerRefererenceNumber);
foreach (var earned in learnerBreakdown.ProviderEarnedTotal)
{
var requiredPaymentId = Guid.NewGuid().ToString();
var month = int.Parse(earned.PeriodName.Substring(0, 2));
var year = int.Parse(earned.PeriodName.Substring(3, 2)) + 2000;
var date = new DateTime(year, month, 1);
var periodNumber = date.GetPeriodNumber();
var periodName = $"{TestEnvironment.Variables.OpaRulebaseYear}-R" + periodNumber.ToString("00");
if (earned.Value > 0)
{
PaymentsManager.SavePaymentDue(requiredPaymentId, provider, learnerUln,
commitment, learnerRefererenceNumber, periodName,
month, year, learningDetails.AimType == AimType.Programme ? (int)TransactionType.OnProgram : (int)TransactionType.OnProgrammeMathsAndEnglish
, earned.Value, learningDetails);
var levyPayment = learnerBreakdown.SfaLevyBudget.Where(x => x.PeriodName == earned.PeriodName).SingleOrDefault();
if (levyPayment != null && levyPayment.Value > 0)
{
PaymentsManager.SavePayment(requiredPaymentId, periodName, month, year,
learningDetails.AimType == AimType.Programme ? (int)TransactionType.OnProgram : (int)TransactionType.OnProgrammeMathsAndEnglish, FundingSource.Levy, levyPayment.Value);
}
var earnedFromEmployer = learnerBreakdown.ProviderEarnedFromEmployers.Where(x => x.PeriodName == earned.PeriodName).SingleOrDefault();
if (earnedFromEmployer != null && earnedFromEmployer.Value > 0)
{
PaymentsManager.SavePayment(requiredPaymentId, periodName, month, year,
learningDetails.AimType == AimType.Programme ? (int)TransactionType.OnProgram : (int)TransactionType.OnProgrammeMathsAndEnglish, FundingSource.CoInvestedEmployer, earnedFromEmployer.Value);
}
var coInvestedBySfaLevy = learnerBreakdown.SfaLevyCoFundBudget.Where(x => x.PeriodName == earned.PeriodName).SingleOrDefault();
if (coInvestedBySfaLevy != null && coInvestedBySfaLevy.Value > 0)
{
PaymentsManager.SavePayment(requiredPaymentId, periodName, month, year,
learningDetails.AimType == AimType.Programme ? (int)TransactionType.OnProgram : (int)TransactionType.OnProgrammeMathsAndEnglish, FundingSource.CoInvestedSfa, coInvestedBySfaLevy.Value);
}
var coInvestedBySfaNonLevy = learnerBreakdown.SfaNonLevyCoFundBudget.Where(x => x.PeriodName == earned.PeriodName).SingleOrDefault();
if (coInvestedBySfaNonLevy != null && coInvestedBySfaNonLevy.Value > 0)
{
PaymentsManager.SavePayment(requiredPaymentId, periodName, month, year,
learningDetails.AimType == AimType.Programme ? (int)TransactionType.OnProgram : (int)TransactionType.OnProgrammeMathsAndEnglish, FundingSource.CoInvestedSfa, coInvestedBySfaNonLevy.Value);
}
var aditionalPayments = learnerBreakdown.SfaLevyAdditionalPayments.Where(x => x.PeriodName == earned.PeriodName).SingleOrDefault();
if (aditionalPayments != null && aditionalPayments.Value > 0)
{
PaymentsManager.SavePayment(requiredPaymentId, periodName, month, year,
learningDetails.AimType == AimType.Programme ? (int)TransactionType.OnProgram : (int)TransactionType.OnProgrammeMathsAndEnglish, FundingSource.FullyFundedSfa, aditionalPayments.Value);
}
}
}
}
private static void ParseEarningAndPaymentsRows(EarningsAndPaymentsBreakdown breakdown, Table earningAndPayments, string[] periodNames)
{
foreach (var row in earningAndPayments.Rows)
{
Match match;
if (row[0] == "Provider Earned Total")
{
ParseNonEmployerRow(row, periodNames, breakdown.ProviderEarnedTotal);
}
else if (row[0] == "Provider Earned from SFA")
{
ParseNonEmployerRow(row, periodNames, breakdown.ProviderEarnedFromSfa);
}
else if (row[0] == "Provider Earned from Employer")
{
ParseEmployerRow(Defaults.EmployerAccountId.ToString(), row, periodNames, breakdown.ProviderEarnedFromEmployers);
}
else if ((match = Regex.Match(row[0], "Provider Earned from Employer ([0-9]{1,})", RegexOptions.IgnoreCase)).Success)
{
ParseEmployerRow(match.Groups[1].Value, row, periodNames, breakdown.ProviderEarnedFromEmployers);
}
else if (row[0] == "Provider Paid by SFA")
{
ParseNonEmployerRow(row, periodNames, breakdown.ProviderPaidBySfa);
}
else if (row[0] == "Payment due from Employer")
{
ParseEmployerRow(Defaults.EmployerAccountId.ToString(), row, periodNames, breakdown.PaymentDueFromEmployers);
}
else if ((match = Regex.Match(row[0], "Payment due from Employer ([0-9]{1,})", RegexOptions.IgnoreCase)).Success)
{
ParseEmployerRow(match.Groups[1].Value, row, periodNames, breakdown.PaymentDueFromEmployers);
}
else if (row[0] == "Levy account debited")
{
ParseEmployerRow(Defaults.EmployerAccountId.ToString(), row, periodNames, breakdown.EmployersLevyAccountDebited);
}
else if ((match = Regex.Match(row[0], "employer ([0-9]{1,}) Levy account debited", RegexOptions.IgnoreCase)).Success)
{
ParseEmployerRow(match.Groups[1].Value, row, periodNames, breakdown.EmployersLevyAccountDebited);
}
else if (row[0] == "SFA Levy employer budget")
{
ParseNonEmployerRow(row, periodNames, breakdown.SfaLevyBudget);
}
else if (row[0] == "SFA Levy co-funding budget")
{
ParseNonEmployerRow(row, periodNames, breakdown.SfaLevyCoFundBudget);
}
else if (row[0] == "SFA non-Levy co-funding budget")
{
ParseNonEmployerRow(row, periodNames, breakdown.SfaNonLevyCoFundBudget);
}
else if (row[0] == "SFA Levy additional payments budget")
{
ParseNonEmployerRow(row, periodNames, breakdown.SfaLevyAdditionalPayments);
}
else if (row[0] == "SFA non-Levy additional payments budget")
{
ParseNonEmployerRow(row, periodNames, breakdown.SfaNonLevyAdditionalPayments);
}
else if (row[0] == "Refund taken by SFA")
{
ParseNonEmployerRow(row, periodNames, breakdown.RefundTakenBySfa);
}
else if (row[0] == "Levy account credited")
{
ParseEmployerRow(Defaults.EmployerAccountId.ToString(), row, periodNames, breakdown.EmployersLevyAccountCredited);
}
else
{
throw new ArgumentException($"Unexpected earning and payments row type of '{row[0]}'");
}
}
}
public abstract void AssertBreakdown(EarningsAndPaymentsBreakdown breakdown, IEnumerable <LearnerResults> submissionResults, EmployerAccountContext employerAccountContext);
