private SummarisationWrapper NewSummarisationWrapper(
IFcsRepository fcsRepository = null,
ISummarisedActualsProcessRepository summarisedActualsProcessRepository = null,
IEnumerable <ISummarisationConfigProvider <FundingType> > fundingTypesProviders = null,
IEnumerable <ISummarisationConfigProvider <CollectionPeriod> > collectionPeriodsProviders = null,
IEnumerable <ISummarisationService> summarisationServices = null,
IDataStorePersistenceService dataStorePersistenceService = null,
Func <IProviderRepository> repositoryFactory = null,
ISummarisationDataOptions dataOptions = null,
ILogger logger = null,
ISummarisationMessage summarisationMessage = null)
{
if (dataOptions == null)
{
dataOptions = new SummarisationDataOptions()
{
DataRetrievalMaxConcurrentCalls = "4"
};
}
return(new SummarisationWrapper(
fcsRepository: fcsRepository,
summarisedActualsProcessRepository: summarisedActualsProcessRepository,
fundingTypesProviders: fundingTypesProviders,
collectionPeriodsProviders: collectionPeriodsProviders,
summarisationServices: summarisationServices,
dataStorePersistenceService: dataStorePersistenceService,
repositoryFactory: repositoryFactory,
dataOptions: dataOptions,
logger: logger));
}
public async Task <ICollection <SummarisedActual> > Summarise(
IEnumerable <SummarisedActual> inputSummarisedActuals,
ISummarisationMessage summarisationMessage,
ICollection <FcsContractAllocation> fcsContractAllocations,
CancellationToken cancellationToken)
{
var providerActuals = _summarisationService.Summarise(fcsContractAllocations, inputSummarisedActuals.ToList()).ToList();
var groupedActuals = inputSummarisedActuals?
.GroupBy(x => x.OrganisationId, StringComparer.OrdinalIgnoreCase)
.Select(sa => new
{
OrganisationId = sa.Key,
SummarisedActuals = sa.ToList()
}).ToList();
foreach (var group in groupedActuals)
{
_logger.LogInfo($"Summarisation Wrapper: Funding Data Removed Rule OrgId: {group.OrganisationId} Start");
var actualsToCarry = await _providerFundingDataRemovedService.FundingDataRemovedAsync(group.OrganisationId, group.SummarisedActuals, summarisationMessage, cancellationToken);
providerActuals.AddRange(actualsToCarry);
_logger.LogInfo($"Summarisation Wrapper: Funding Data Removed Rule OrgId: {group.OrganisationId} End");
}
return(providerActuals);
}
public CollectionReturn MapCollectionReturn(ISummarisationMessage summarisationMessage)
{
return(new CollectionReturn
{
CollectionReturnCode = summarisationMessage.CollectionReturnCode,
CollectionType = summarisationMessage.CollectionType,
});
}
public async Task <ICollection <SummarisedActual> > CollateAndSummariseAsync(ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
_logger.LogInfo($"Summarisation Wrapper: Retrieving Collection Periods Start");
_logger.LogInfo($"Summarisation Message: CollectionType : {summarisationMessage.CollectionType}, CollectionReturnCode: {summarisationMessage.CollectionReturnCode}, ILRCollectionYear: {summarisationMessage.CollectionYear}, ILRReturnPeriod: {summarisationMessage.CollectionMonth}");
var collectionPeriods = _collectionPeriodsProviders.Single(w => w.CollectionType.Equals(summarisationMessage.CollectionType, StringComparison.OrdinalIgnoreCase)).Provide();
var fundingTypeConfiguration = _fundingTypesProviders.Single(w => w.CollectionType.Equals(summarisationMessage.CollectionType, StringComparison.OrdinalIgnoreCase)).Provide();
_logger.LogInfo($"Summarisation Wrapper: Retrieving Collection Periods End");
_logger.LogInfo($"Summarisation Wrapper: Retrieving FCS Contracts Start");
var periodCodes = fundingTypeConfiguration
.SelectMany(ft => ft.FundingStreams.Select(fs => fs.PeriodCode)).Distinct().ToList();
var fcsContractAllocations = await _fcsRepository.RetrieveContractAllocationsAsync(periodCodes, cancellationToken);
_logger.LogInfo($"Summarisation Wrapper: Retrieving FCS Contracts End");
var summarisedActuals = new List <SummarisedActual>();
ICollection <TouchpointProvider> providerIdentifiers;
providerIdentifiers = await _repositoryFactory.Invoke().GetAllIdentifiersAsync(summarisationMessage.CollectionYear, cancellationToken);
_logger.LogInfo($"Summarisation Wrapper: Providers to be summarised : {providerIdentifiers.Count}");
_logger.LogInfo($"Summarisation Wrapper: Retrieving Providers Data Start");
var providersData = await RetrieveProvidersData(providerIdentifiers.ToList(), summarisationMessage, cancellationToken);
_logger.LogInfo($"Summarisation Wrapper: Retrieving Providers Data End");
_logger.LogInfo($"Summarisation Wrapper: Summarisation Start");
int runningCount = 1;
int totalProviderCount = providerIdentifiers.Count;
foreach (var provider in providerIdentifiers)
{
_logger.LogInfo($"Summarisation Wrapper: Summarising Data of UKPRN: {provider.UKPRN} UKPRN: {provider.TouchpointId} Start, {runningCount} / {totalProviderCount}");
var providerData = providersData.First(q => q.Provider.UKPRN == provider.UKPRN && q.Provider.TouchpointId.Equals(provider.TouchpointId, StringComparison.OrdinalIgnoreCase));
var providerActuals = await _providerSummarisationService.Summarise(providerData, collectionPeriods, fundingTypeConfiguration, fcsContractAllocations, summarisationMessage, cancellationToken);
summarisedActuals.AddRange(providerActuals);
_logger.LogInfo($"Summarisation Wrapper: Summarising Data of UKPRN: {provider.UKPRN} UKPRN: {provider.TouchpointId} End, {runningCount++} / {totalProviderCount}");
}
_logger.LogInfo($"Summarisation Wrapper: Summarisation End");
return(summarisedActuals);
}
public async Task <LearningProvider> ProvideAsync(int ukprn, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
var taskResults = await Task.WhenAll(_providers.Where(w => w.CollectionType == summarisationMessage.CollectionType).Select(p => p.ProvideAsync(ukprn, summarisationMessage, cancellationToken)));
return(new LearningProvider
{
UKPRN = ukprn,
LearningDeliveries = taskResults.SelectMany(x => x).ToList()
});
}
public async Task <ICollection <SummarisedActual> > Summarise(ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
var summarisationProcess = _summarisationProcesses.Single(p => p.ProcessType.Equals(summarisationMessage.ProcessType, StringComparison.OrdinalIgnoreCase));
var summarisedActuals = await summarisationProcess.CollateAndSummariseAsync(summarisationMessage, cancellationToken);
_logger.LogInfo($"Summarisation Wrapper: Storing data to Summarised Actuals Start");
await _dataStorePersistenceService.StoreSummarisedActualsDataAsync(
summarisedActuals.ToList(),
summarisationMessage,
cancellationToken);
_logger.LogInfo($"Summarisation Wrapper: Storing data to Summarised Actuals End");
return(summarisedActuals);
}
public ICollection <SummarisedActual> Summarise(
ICollection <FundingStream> fundingStreams,
LearningProvider provider,
ICollection <FcsContractAllocation> allocations,
ICollection <CollectionPeriod> collectionPeriods,
ISummarisationMessage summarisationMessage)
{
var summarisedActuals = new List <SummarisedActual>();
foreach (var fs in fundingStreams)
{
var fundingStreamSummarisedActuals = Summarise(fs, provider, allocations, collectionPeriods, summarisationMessage);
summarisedActuals.AddRange(fundingStreamSummarisedActuals);
}
return(summarisedActuals);
}
public async Task PublishAsync(ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
var collectionReturn = await _summarisedActualsRepository.GetLastCollectionReturnAsync(summarisationMessage.CollectionType, summarisationMessage.CollectionReturnCode, cancellationToken);
var eventLog = _eventLogMapper.Map(collectionReturn);
_logger.LogInfo($"Publish to BAU: Retrieving and storing data to BAU Start");
var summarisedActuals = await _summarisedActualsRepository.GetSummarisedActualsAsync(collectionReturn.Id, cancellationToken);
var summarisedActualsBAU = _summarisedActualMapper.Map(summarisedActuals, summarisationMessage.CollectionType, summarisationMessage.CollectionReturnCode);
await _dataStorePersistenceService.StoreSummarisedActualsDataAsync(
summarisedActualsBAU,
eventLog,
cancellationToken);
_logger.LogInfo($"Publish to BAU: Retrieving and storing data to BAU End");
}
public async Task <ICollection <LearningDelivery> > ProvideAsync(int ukprn, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
using (var easContext = _easContext())
{
var learningDeliveries = await easContext.EasSubmissionValues
.Where(sv => sv.EasSubmission.Ukprn == ukprn.ToString())
.Join(easContext.PaymentTypes, sv => sv.PaymentId, p => p.PaymentId, (value, type) => new { value.CollectionPeriod, value.PaymentValue, type.PaymentName })
.GroupBy(x => x.PaymentName)
.Select(ld => new LearningDelivery
{
LearnRefNumber = string.Empty,
AimSeqNumber = 0,
Fundline = ld.Key,
PeriodisedData = ld.GroupBy(x => x.PaymentName).Select(pd => new PeriodisedData
{
AttributeName = string.Empty,
Periods = Enumerable.Range(1, 12)
.GroupJoin(
ld,
range => range,
ldr => ldr.CollectionPeriod,
(irange, ldRows) => new
{
CollectionPeriod = irange,
LearningDeliveryRows = ldRows,
})
.SelectMany(
result => result.LearningDeliveryRows.DefaultIfEmpty(),
(x, y) => new Period
{
PeriodId = x.CollectionPeriod,
Value = y.PaymentValue,
}).ToList(),
}).ToList(),
})
.ToListAsync(cancellationToken);
return(learningDeliveries);
}
}
public async Task StoreSummarisedActualsDataAsync(
IList <Service.Model.SummarisedActual> summarisedActuals,
ISummarisationMessage summarisationMessage,
CancellationToken cancellationToken)
{
using (var sqlConnection = new SqlConnection(_summarisationDataOptions.SummarisedActualsConnectionString))
{
await sqlConnection.OpenAsync(cancellationToken);
using (var transaction = sqlConnection.BeginTransaction())
{
try
{
var collectionReturn = this._collectionReturnMapper.MapCollectionReturn(summarisationMessage);
// Remove Existing Summarised Actuals for the given CollectionReturnCode
collectionReturn.Id = sqlConnection.ExecuteScalar <int>(GetCollectionReturnSql, collectionReturn, transaction);
sqlConnection.Execute(DeleteSummarisedActualsSql, collectionReturn, transaction);
sqlConnection.Execute(DeleteCollectionReturnSql, collectionReturn, transaction);
// Persist new set of Summarised Actuals
var collectionReturnId = await this.InsertCollectionReturnAsync(collectionReturn, sqlConnection, transaction);
await this._summarisedActualsPersist.Save(summarisedActuals, collectionReturnId, sqlConnection, transaction, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}
}
}
public async Task <ICollection <SummarisedActual> > CollateAndSummariseAsync(ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
_logger.LogInfo($"Summarisation Message: CollectionType : {summarisationMessage.CollectionType}, CollectionReturnCode: {summarisationMessage.CollectionReturnCode}, CollectionYear: {summarisationMessage.CollectionYear}, ReturnPeriod: {summarisationMessage.CollectionMonth}");
_logger.LogInfo($"Summarisation Wrapper: Retrieving Generic Collection Data Start");
var genericCollectionData = await _genericCollectionRepository.RetrieveAsync(summarisationMessage.CollectionType, cancellationToken);
var ukprns = genericCollectionData.Select(gc => int.Parse(gc.OrganisationId)).Distinct().ToList();
var fundingStreamPeriodCodes = genericCollectionData.Select(gc => gc.FundingStreamPeriodCode).Distinct().ToList();
var fcsContractAllocations = await _fcsRepository.RetrieveContractAllocationsAsync(fundingStreamPeriodCodes, cancellationToken);
var genericCollectionContracts = fcsContractAllocations.Where(u => ukprns.Contains(u.DeliveryUkprn.Value)).Distinct().ToList();
var summarisedActuals = await _providerSummarisationService.Summarise(genericCollectionData, summarisationMessage, genericCollectionContracts, cancellationToken);
_logger.LogInfo($"Summarisation Wrapper: Retrieving Retrieving Generic Collection Data End");
_logger.LogInfo($"Summarisation Wrapper: Summarisation End");
return(summarisedActuals);
}
public async Task <ICollection <SummarisedActual> > Summarise(TouchpointProviderFundingData providerData, ICollection <CollectionPeriod> collectionPeriods, ICollection <FundingType> fundingTypes, ICollection <FcsContractAllocation> contractAllocations, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
var providerActuals = new List <SummarisedActual>();
var provider = providerData.Provider;
foreach (var summarisationType in summarisationMessage.SummarisationTypes)
{
_logger.LogInfo($"Summarisation Wrapper: Summarising Data of UKPRN: {providerData.Provider.UKPRN}, Fundmodel {summarisationType} Start");
var fundingStreams = fundingTypes?
.Where(x => x.SummarisationType.Equals(summarisationType, StringComparison.OrdinalIgnoreCase))
.SelectMany(fs => fs.FundingStreams)
.ToList();
var providerfundingstreamsContracts = _providerContractsService.GetProviderContracts(provider.UKPRN, fundingStreams, contractAllocations, cancellationToken);
var summarisedData = _summarisationService.Summarise(providerfundingstreamsContracts.FundingStreams, providerData, providerfundingstreamsContracts.FcsContractAllocations, collectionPeriods);
providerActuals.AddRange(summarisedData);
_logger.LogInfo($"Summarisation Wrapper: Summarising Data of UKPRN: {provider.UKPRN}, Fundmodel {summarisationType} End");
}
if (!summarisationMessage.ProcessType.Equals(ProcessTypeConstants.Payments, StringComparison.OrdinalIgnoreCase))
{
_logger.LogInfo($"Summarisation Wrapper: Funding Data Removed Rule UKPRN: {provider.UKPRN} Start");
var organisationId = providerActuals.Select(x => x.OrganisationId).FirstOrDefault();
var actualsToCarry = await _providerFundingDataRemovedService.FundingDataRemovedAsync(organisationId, providerData.Provider.TouchpointId, providerActuals, summarisationMessage, cancellationToken);
providerActuals.AddRange(actualsToCarry);
_logger.LogInfo($"Summarisation Wrapper: Funding Data Removed Rule UKPRN: {provider.UKPRN} End");
}
return(providerActuals);
}
public ICollection <SummarisedActual> Summarise(
FundingStream fundingStream,
LearningProvider provider,
ICollection <FcsContractAllocation> allocations,
ICollection <CollectionPeriod> collectionPeriods,
ISummarisationMessage summarisationMessage)
{
var summarisedActuals = new List <SummarisedActual>();
int currentCollectionPeriod = summarisationMessage.CollectionMonth;
int previousCollectionYear = 0;
int previousCollectionMonth = 0;
switch (summarisationMessage.CollectionMonth)
{
case 2:
previousCollectionMonth = 13;
previousCollectionYear = summarisationMessage.CollectionYear - 101;
break;
case 3:
previousCollectionMonth = 14;
previousCollectionYear = summarisationMessage.CollectionYear - 101;
break;
default:
previousCollectionMonth = 0;
previousCollectionYear = 0;
break;
}
if (fundingStream.PeriodCode.Equals(FundingStreamConstants.Levy1799, StringComparison.OrdinalIgnoreCase) ||
fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy2019, StringComparison.OrdinalIgnoreCase))
{
collectionPeriods = collectionPeriods.Where(w =>
(w.CollectionYear == summarisationMessage.CollectionYear && w.CollectionMonth == summarisationMessage.CollectionMonth)
||
(w.CollectionYear == previousCollectionYear && w.CollectionMonth == previousCollectionMonth)
).ToList();
}
else if (summarisationMessage.CollectionYear == 2021 && fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy_APPS2021, StringComparison.OrdinalIgnoreCase))
{
collectionPeriods = collectionPeriods.Where(w => w.CollectionYear == summarisationMessage.CollectionYear && w.CollectionMonth <= 12).ToList();
}
else if (summarisationMessage.CollectionYear == 2021 && fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy_APPS1920, StringComparison.OrdinalIgnoreCase))
{
collectionPeriods = collectionPeriods.Where(w => w.CollectionYear == previousCollectionYear && w.CollectionMonth <= 12).ToList();
}
else if (summarisationMessage.CollectionYear == 1920 && fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy_APPS1920, StringComparison.OrdinalIgnoreCase))
{
collectionPeriods = collectionPeriods.Where(w => w.CollectionYear == summarisationMessage.CollectionYear && w.CollectionMonth <= 12).ToList();
}
else if (summarisationMessage.CollectionYear == 1920 && fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy_APPS1819, StringComparison.OrdinalIgnoreCase))
{
collectionPeriods = collectionPeriods.Where(w => w.CollectionYear == previousCollectionYear && w.CollectionMonth <= 12).ToList();
}
else if (fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy_ANLAP2018, StringComparison.OrdinalIgnoreCase) ||
fundingStream.PeriodCode.Equals(FundingStreamConstants.NonLevy_1618NLAP2018, StringComparison.OrdinalIgnoreCase))
{
// No Filter needed. Need every thing from Collection Periods configuration
}
else
{
collectionPeriods = collectionPeriods.Where(w => w.CollectionYear == summarisationMessage.CollectionYear || w.CollectionYear == previousCollectionYear).ToList();
}
foreach (var fundLine in fundingStream.FundLines)
{
IEnumerable <PeriodisedData> periodisedData;
if (fundLine.LineType.Equals(FundingStreamConstants.LineType_EAS, StringComparison.OrdinalIgnoreCase))
{
periodisedData = provider
.LearningDeliveries
.Where(ld => ld.Fundline.Equals(fundLine.Fundline, StringComparison.OrdinalIgnoreCase))
.SelectMany(x => x.PeriodisedData);
}
else
{
periodisedData = provider
.LearningDeliveries
.Where(ld => ld.Fundline.Equals(fundLine.Fundline, StringComparison.OrdinalIgnoreCase))
.SelectMany(x => x.PeriodisedData
.Where(pd => pd.ApprenticeshipContractType == fundingStream.ApprenticeshipContractType &&
fundingStream.FundingSources.Contains(pd.FundingSource) &&
fundingStream.TransactionTypes.Contains(pd.TransactionType)));
}
var periods = GetPeriodsForFundLine(periodisedData, fundLine);
summarisedActuals.AddRange(SummarisePeriods(periods, collectionPeriods));
}
var fcsAllocations = allocations.GroupBy(g => new { g.FundingStreamPeriodCode, g.DeliveryOrganisation })
.Select(x => new
{
FundingStreamPeriodCode = x.Key.FundingStreamPeriodCode,
DeliveryOrganisation = x.Key.DeliveryOrganisation,
ContractAllocationNumber = allocations.Where(y => x.Key.FundingStreamPeriodCode == y.FundingStreamPeriodCode)
.OrderByDescending(z => z.ContractStartDate)
.ThenByDescending(t => t.ContractEndDate)
.FirstOrDefault()?.ContractAllocationNumber,
}).ToDictionary(a => a.FundingStreamPeriodCode, StringComparer.OrdinalIgnoreCase);
return(summarisedActuals
.GroupBy(grp => grp.Period)
.Select(g =>
new SummarisedActual
{
OrganisationId = fcsAllocations[fundingStream.PeriodCode].DeliveryOrganisation,
DeliverableCode = fundingStream.DeliverableLineCode,
FundingStreamPeriodCode = fundingStream.PeriodCode,
Period = g.Key,
ActualValue = Math.Round(g.Sum(x => x.ActualValue), 2),
ContractAllocationNumber = fcsAllocations[fundingStream.PeriodCode].ContractAllocationNumber,
PeriodTypeCode = PeriodTypeCodeConstants.CalendarMonth
}).ToList());
}
public async Task <ICollection <SummarisedActual> > Summarise(LearningProvider providerData, ICollection <CollectionPeriod> collectionPeriods, ICollection <FundingType> fundingTypes, ICollection <FcsContractAllocation> contractAllocations, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
var providerActuals = new List <SummarisedActual>();
foreach (var summarisationType in summarisationMessage.SummarisationTypes)
{
_logger.LogInfo($"Summarisation Wrapper: Summarising Data of UKPRN: {providerData.UKPRN}, Fundmodel {summarisationType} Start");
var fundingStreams = fundingTypes?
.Where(x => x.SummarisationType.Equals(summarisationType, StringComparison.OrdinalIgnoreCase))
.SelectMany(fs => fs.FundingStreams)
.ToList();
var providerfundingstreamsContracts = await _providerContractsService.GetProviderContracts(providerData.UKPRN, fundingStreams, contractAllocations, cancellationToken);
var summarisedData = _summarisationService.Summarise(providerfundingstreamsContracts.FundingStreams, providerData, providerfundingstreamsContracts.FcsContractAllocations, collectionPeriods, summarisationMessage);
providerActuals.AddRange(summarisedData);
_logger.LogInfo($"Summarisation Wrapper: Summarising Data of UKPRN: {providerData.UKPRN}, Fundmodel {summarisationType} End");
}
_logger.LogInfo($"Summarisation Wrapper: Funding Data Removed Rule UKPRN: {providerData.UKPRN} Start");
var organisationId = contractAllocations.Where(w => w.DeliveryUkprn == providerData.UKPRN).Select(s => s.DeliveryOrganisation).FirstOrDefault();
var actualsToCarry = await _providerFundingDataRemovedService.FundingDataRemovedAsync(organisationId, providerActuals, summarisationMessage, cancellationToken);
var fundingStreamPeriodCodesNotRequiredForActuals =
GetFundingStreamsNotRequiredForCarryOver(summarisationMessage.CollectionYear,
summarisationMessage.CollectionMonth);
var filteredActualsToCarry = actualsToCarry.Where(x => !fundingStreamPeriodCodesNotRequiredForActuals.Contains(x.FundingStreamPeriodCode)).ToList();
providerActuals.AddRange(filteredActualsToCarry);
_logger.LogInfo($"Summarisation Wrapper: Funding Data Removed Rule UKPRN: {providerData.UKPRN} End");
return(providerActuals);
}
public async Task <TouchpointProviderFundingData> ProvideAsync(TouchpointProvider touchpointProvider, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
var providers = _providers;
var taskResults = await Task.WhenAll(providers.Select(p => p.ProvideAsync(touchpointProvider, summarisationMessage, cancellationToken)));
return(new TouchpointProviderFundingData
{
Provider = touchpointProvider,
FundingValues = taskResults.SelectMany(x => x).ToList()
});
}
public ICollection <SummarisedActual> Summarise(ICollection <FundingStream> fundingStreams, LearningProvider provider, ICollection <FcsContractAllocation> allocations, ICollection <CollectionPeriod> collectionPeriods, ISummarisationMessage summarisationMessage)
{
var esfAllocations = allocations.Where(w => w.FundingStreamPeriodCode.Equals(FSPcode, StringComparison.OrdinalIgnoreCase));
var summarisedActuals = new List <SummarisedActual>();
foreach (var allocation in esfAllocations)
{
var allocationSummarisedActuals = Summarise(fundingStreams, provider, allocation, collectionPeriods);
summarisedActuals.AddRange(allocationSummarisedActuals);
}
return(summarisedActuals);
}
private async Task <LearningProvider> RetrieveProviderData(int identifier, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
var repo = _repositoryFactory();
return(await repo.ProvideAsync(identifier, summarisationMessage, cancellationToken));
}
public async Task <ICollection <SummarisedActual> > FundingDataRemovedAsync(string organisationId, string uopCode, ICollection <SummarisedActual> providerActuals, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
var latestCollectionReturn = await _summarisedActualsProcessRepository.GetLastCollectionReturnForReRunAsync(summarisationMessage.CollectionType, summarisationMessage.CollectionReturnCode, cancellationToken);
var actualsToCarry = new List <SummarisedActual>();
if (latestCollectionReturn != null)
{
var previousActuals = await _summarisedActualsProcessRepository.GetSummarisedActualsAsync(latestCollectionReturn.Id, organisationId, uopCode, cancellationToken);
var comparer = new CarryOverActualsComparer();
actualsToCarry = previousActuals.Except(providerActuals, comparer).ToList();
foreach (var actuals in actualsToCarry)
{
actuals.ActualVolume = 0;
actuals.ActualValue = 0;
}
}
return(actualsToCarry);
}
public async Task <ICollection <SummarisedActual> > CollateAndSummariseAsync(ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
_logger.LogInfo($"Summarisation Wrapper: Retrieving Collection Periods Start");
_logger.LogInfo($"Summarisation Message: CollectionType : {summarisationMessage.CollectionType}, CollectionReturnCode: {summarisationMessage.CollectionReturnCode}, ILRCollectionYear: {summarisationMessage.CollectionYear}, ILRReturnPeriod: {summarisationMessage.CollectionMonth}");
var collectionPeriods = _collectionPeriodsProviders.Single(w => w.CollectionType.Equals(summarisationMessage.CollectionType, StringComparison.OrdinalIgnoreCase)).Provide();
var fundingTypeConfiguration = _fundingTypesProviders.Single(w => w.CollectionType.Equals(summarisationMessage.CollectionType, StringComparison.OrdinalIgnoreCase)).Provide();
_logger.LogInfo($"Summarisation Wrapper: Retrieving Collection Periods End");
_logger.LogInfo($"Summarisation Wrapper: Retrieving FCS Contracts Start");
var relevantFundingStreams = fundingTypeConfiguration.ToList()
.SelectMany(ftc => ftc.FundingStreams.Select(fs => fs.PeriodCode)).Distinct().ToList();
var fcsContractAllocations = await _fcsRepository.RetrieveContractAllocationsAsync(relevantFundingStreams, cancellationToken);
_logger.LogInfo($"Summarisation Wrapper: Retrieving FCS Contracts End");
var summarisedActuals = new List <SummarisedActual>();
ICollection <int> providerIdentifiers;
if (summarisationMessage.Ukprn.HasValue && summarisationMessage.Ukprn > 0)
{
providerIdentifiers = new List <int> {
summarisationMessage.Ukprn.Value
};
}
else
{
providerIdentifiers = await _repositoryFactory().GetAllIdentifiersAsync(summarisationMessage.CollectionType, cancellationToken);
}
_logger.LogInfo($"Summarisation Wrapper: Providers to be summarised : {providerIdentifiers.Count}");
_logger.LogInfo($"Summarisation Wrapper: Retrieving Providers Data Start");
var providersData = await RetrieveProvidersData(providerIdentifiers, summarisationMessage, cancellationToken);
_logger.LogInfo($"Summarisation Wrapper: Retrieving Providers Data End");
_logger.LogInfo($"Summarisation Wrapper: Summarisation Start");
int runningCount = 1;
int totalProviderCount = providersData.Count;
foreach (var provider in providersData)
{
_logger.LogInfo($"Summarisation Wrapper: Summarising Data of UKPRN: {provider.UKPRN} Start, {runningCount} / {totalProviderCount}");
var providerActuals = await _providerSummarisationService.Summarise(provider, collectionPeriods, fundingTypeConfiguration, fcsContractAllocations, summarisationMessage, cancellationToken);
summarisedActuals.AddRange(providerActuals);
_logger.LogInfo($"Summarisation Wrapper: Summarising Data of UKPRN: {provider.UKPRN} End, {runningCount++} / {totalProviderCount}");
}
//Funding Data Removed logic
_logger.LogInfo($"Summarisation Process: Funding Data Removed Start");
var actualsToCarry = await _fundingDataRemovedService.FundingDataRemovedAsync(summarisedActuals, summarisationMessage, cancellationToken);
summarisedActuals.AddRange(actualsToCarry);
_logger.LogInfo($"Summarisation Process: Funding Data Removed End");
_logger.LogInfo($"Summarisation Wrapper: Summarisation End");
return(summarisedActuals);
}
private async Task <IReadOnlyCollection <TouchpointProviderFundingData> > RetrieveProvidersData(ICollection <TouchpointProvider> providerIdentifiers, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
var identifiers = new ConcurrentQueue <TouchpointProvider>(providerIdentifiers);
var concurrentBag = new ConcurrentBag <TouchpointProviderFundingData>();
var providerIdentifiersList = providerIdentifiers.ToList();
var tasks = Enumerable.Range(1, _dataRetrievalMaxConcurrentCalls).Select(async _ =>
{
int totalCount = providerIdentifiers.Count;
while (identifiers.TryDequeue(out TouchpointProvider identifier))
{
var index = providerIdentifiersList.IndexOf(identifier) + 1;
_logger.LogInfo($"Summarisation Wrapper: Retrieving Data for UKPRN: {identifier} Start, {index} / {totalCount}");
var learningProvider = await RetrieveProviderData(identifier, summarisationMessage, cancellationToken);
concurrentBag.Add(learningProvider);
_logger.LogInfo($"Summarisation Wrapper: Retrieving Data for UKPRN: {identifier} End, {index} / {totalCount}");
}
}).ToList();
await Task.WhenAll(tasks);
return(concurrentBag);
}
public async Task <ICollection <FundingValue> > ProvideAsync(TouchpointProvider touchpointProvider, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
var maxDate = new DateTime(summarisationMessage.CollectionYear % 100 + 2000, 3, 31);
using (var ncsContext = _ncsContext())
{
var fundingValues = await ncsContext.FundingValues
.Where(fv => fv.Ukprn == touchpointProvider.UKPRN &&
fv.TouchpointId == touchpointProvider.TouchpointId &&
fv.CollectionYear == summarisationMessage.CollectionYear &&
fv.OutcomeEffectiveDate <= maxDate)
.Select(s => new FundingValue
{
CollectionYear = s.CollectionYear,
CalendarMonth = s.OutcomeEffectiveDateMonth,
OutcomeType = s.OutcomeType,
Value = s.Value
}).ToListAsync(cancellationToken);
return(fundingValues);
}
}
public async Task <ICollection <LearningDelivery> > ProvideAsync(int ukprn, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
List <int> CollectionYears = new List <int>
{
summarisationMessage.CollectionYear,
summarisationMessage.CollectionYear - 101,
};
int previousCollectionYear = summarisationMessage.CollectionYear - 101;
int previousCollectionMonth = 12;
switch (summarisationMessage.CollectionMonth)
{
case 2:
previousCollectionMonth = 13;
break;
case 3:
previousCollectionMonth = 14;
break;
default:
previousCollectionMonth = 12;
break;
}
using (var contextFactory = _dasContext())
{
var preSummarisedData = await contextFactory.Payments
.Where(p => p.Ukprn == ukprn &&
p.ContractType == ContractTypeConstants.NonLevy &&
(
(
CollectionYears.Contains(p.AcademicYear) ||
FundlineConstants.Apps1618NonLevyContractProcured.Equals(p.LearningAimFundingLineType, StringComparison.OrdinalIgnoreCase) ||
FundlineConstants.Apps19plusNonLevyContractProcured.Equals(p.LearningAimFundingLineType, StringComparison.OrdinalIgnoreCase)
) &&
!(p.AcademicYear == previousCollectionYear && p.CollectionPeriod > previousCollectionMonth)
)
)
.Select(q1 => new
{
q1.ContractType,
q1.FundingSource,
q1.TransactionType,
q1.AcademicYear,
q1.DeliveryPeriod,
FundingLineType = CollectionYears.Contains(q1.AcademicYear) ? q1.ReportingAimFundingLineType : q1.LearningAimFundingLineType,
q1.Amount,
}
)
.GroupBy(x => new { x.ContractType, x.FundingSource, x.TransactionType, x.AcademicYear, x.DeliveryPeriod, x.FundingLineType })
.Select(obj => new
{
ContractType = obj.Key.ContractType,
FundingSource = obj.Key.FundingSource,
TransactionType = obj.Key.TransactionType,
AcademicYear = obj.Key.AcademicYear,
DeliveryPeriod = obj.Key.DeliveryPeriod,
FundingLineType = obj.Key.FundingLineType,
Amount = obj.Sum(s => s.Amount),
}).ToListAsync(cancellationToken);
var learningDeliveries = preSummarisedData
.GroupBy(x => x.FundingLineType, StringComparer.OrdinalIgnoreCase)
.Select(ld => new LearningDelivery
{
Fundline = ld.Key,
PeriodisedData = ld.Select(pd => new PeriodisedData
{
ApprenticeshipContractType = pd.ContractType,
FundingSource = pd.FundingSource,
TransactionType = pd.TransactionType,
Periods = new List <Period>
{
new Period
{
CollectionMonth = pd.DeliveryPeriod,
CollectionYear = pd.AcademicYear,
Value = pd.Amount,
},
},
}).ToList(),
}).ToList();
return(learningDeliveries);
}
}
private async Task <TouchpointProviderFundingData> RetrieveProviderData(TouchpointProvider identifier, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
var repo = _repositoryFactory();
return(await repo.ProvideAsync(identifier, summarisationMessage, cancellationToken));
}
public async Task <ICollection <LearningDelivery> > ProvideAsync(int ukprn, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
int previousCollectionYear = summarisationMessage.CollectionYear - 101;
var collectionPeriods = _collectionPeriodProvider.Provide();
List <int> CollectionYears = new List <int>()
{
summarisationMessage.CollectionYear,
previousCollectionYear,
};
string previouscollectionPeriodName = string.Empty;
string currentcollectionPeriodName = $"{summarisationMessage.CollectionYear}-R{summarisationMessage.CollectionMonth:D2}";
switch (summarisationMessage.CollectionMonth)
{
case 2:
previouscollectionPeriodName = $"{previousCollectionYear}-R13";
break;
case 3:
previouscollectionPeriodName = $"{previousCollectionYear}-R14";
break;
default:
previouscollectionPeriodName = string.Empty;
break;
}
List <string> CollectionPeriodNames = new List <string>()
{
currentcollectionPeriodName,
previouscollectionPeriodName,
};
using (var easContext = _dasContext())
{
var nonlevyEAS = await easContext.ProviderAdjustmentPayments
.Where(sv => sv.Ukprn == ukprn &&
!FundlineConstants.EasLines_Levy_NonLevy2019.Contains(sv.PaymentTypeName))
.Select(q1 => new
{
q1.PaymentTypeName,
CollectionMonth = q1.SubmissionCollectionPeriod,
CollectionYear = q1.SubmissionAcademicYear,
Value = q1.Amount,
})
.ToListAsync(cancellationToken);
var levyEAS = (await easContext.ProviderAdjustmentPayments
.Where(sv => sv.Ukprn == ukprn &&
CollectionPeriodNames.Contains(sv.CollectionPeriodName) &&
FundlineConstants.EasLines_Levy_NonLevy2019.Contains(sv.PaymentTypeName))
.ToListAsync(cancellationToken))
.Select(p =>
{
var collectionPeriod = GetCollectionPeriodFor(collectionPeriods, p.CollectionPeriodYear, p.CollectionPeriodMonth);
return(new
{
p.PaymentTypeName,
CollectionMonth = collectionPeriod?.CollectionMonth ?? 0,
CollectionYear = collectionPeriod?.CollectionYear ?? 0,
Value = p.Amount,
});
}).ToList();
var eas = nonlevyEAS.Concat(levyEAS).ToList();
var learningDeliveries = eas
.GroupBy(x => x.PaymentTypeName)
.Select(ld => new LearningDelivery
{
Fundline = ld.Key,
PeriodisedData = ld.Select(pd => new PeriodisedData
{
Periods = new List <Period>
{
new Period
{
CollectionMonth = pd.CollectionMonth,
CollectionYear = pd.CollectionYear,
Value = pd.Value,
},
},
}).ToList(),
}).ToList();
return(learningDeliveries);
}
}
public async Task <ICollection <LearningDelivery> > ProvideAsync(int ukprn, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
using (var ilrContext = _ilr())
{
var learningDeliveries = await ilrContext.FM25_Learners
.Where(ld => ld.UKPRN == ukprn)
.Select(ld => new LearningDelivery
{
LearnRefNumber = ld.LearnRefNumber,
Fundline = ld.FundLine,
PeriodisedData = ld.FM25_FM35_Learner_PeriodisedValues
.Where(x => (x.Period_1 != 0 || x.Period_2 != 0 || x.Period_3 != 0 || x.Period_4 != 0 ||
x.Period_5 != 0 || x.Period_6 != 0 || x.Period_7 != 0 || x.Period_8 != 0 ||
x.Period_9 != 0 || x.Period_10 != 0 || x.Period_11 != 0 || x.Period_12 != 0))
.Select(pv => new PeriodisedData
{
AttributeName = pv.AttributeName,
Periods = new List <Period>
{
new Period
{
PeriodId = 1,
Value = pv.Period_1,
},
new Period
{
PeriodId = 2,
Value = pv.Period_2,
},
new Period
{
PeriodId = 3,
Value = pv.Period_3,
},
new Period
{
PeriodId = 4,
Value = pv.Period_4,
},
new Period
{
PeriodId = 5,
Value = pv.Period_5,
},
new Period
{
PeriodId = 6,
Value = pv.Period_6,
},
new Period
{
PeriodId = 7,
Value = pv.Period_7,
},
new Period
{
PeriodId = 8,
Value = pv.Period_8,
},
new Period
{
PeriodId = 9,
Value = pv.Period_9,
},
new Period
{
PeriodId = 10,
Value = pv.Period_10,
},
new Period
{
PeriodId = 11,
Value = pv.Period_11,
},
new Period
{
PeriodId = 12,
Value = pv.Period_12,
},
},
}).ToList(),
}).ToListAsync(cancellationToken);
return(learningDeliveries);
}
}
public Task <ICollection <LearningDelivery> > ProvideAsync(int ukprn, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken) => ProvideAsync(ukprn, cancellationToken);
private async Task <IDictionary <int, LearningProvider> > RetrieveProvidersData(IList <int> providerIdentifiers, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
var identifiers = new ConcurrentQueue <int>(providerIdentifiers);
var tasks = Enumerable.Range(1, _dataRetrievalMaxConcurrentCalls).Select(async _ =>
{
var dictionary = new Dictionary <int, LearningProvider>();
int totalCount = providerIdentifiers.Count;
while (identifiers.TryDequeue(out int identifier))
{
_logger.LogInfo($"Summarisation Wrapper: Retrieving Data for UKPRN: {identifier} Start, {providerIdentifiers.IndexOf(identifier) + 1} / {totalCount}");
dictionary.Add(identifier, await RetrieveProviderData(identifier, summarisationMessage, cancellationToken));
_logger.LogInfo($"Summarisation Wrapper: Retrieving Data for UKPRN: {identifier} End, {providerIdentifiers.IndexOf(identifier) + 1} / {totalCount}");
}
return(dictionary);
}).ToList();
await Task.WhenAll(tasks);
return(tasks.SelectMany(t => t.Result).ToDictionary(p => p.Key, p => p.Value));
}
public async Task <ICollection <LearningDelivery> > ProvideAsync(int ukprn, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
int currentCollectionYear = summarisationMessage.CollectionYear;
int currentCollectionPeriod = summarisationMessage.CollectionMonth;
int previousCollectionYear = summarisationMessage.CollectionYear - 101;
int previousCollectionMonth = 0;
switch (summarisationMessage.CollectionMonth)
{
case 2:
previousCollectionMonth = 13;
break;
case 3:
previousCollectionMonth = 14;
break;
default:
previousCollectionMonth = 0;
break;
}
using (var contextFactory = _dasContext())
{
var preSummarisedData = await contextFactory.Payments
.Where(p => p.Ukprn == ukprn && p.ContractType == ContractTypeConstants.Levy &&
(
(p.AcademicYear == currentCollectionYear && p.CollectionPeriod == currentCollectionPeriod)
||
(p.AcademicYear == previousCollectionYear && p.CollectionPeriod == previousCollectionMonth))
)
.GroupBy(x => new { x.ContractType, x.FundingSource, x.TransactionType, x.AcademicYear, x.CollectionPeriod, x.ReportingAimFundingLineType })
.Select(obj => new
{
ContractType = obj.Key.ContractType,
FundingSource = obj.Key.FundingSource,
TransactionType = obj.Key.TransactionType,
AcademicYear = obj.Key.AcademicYear,
CollectionPeriod = obj.Key.CollectionPeriod,
ReportingAimFundingLineType = obj.Key.ReportingAimFundingLineType,
Amount = obj.Sum(s => s.Amount),
}).ToListAsync(cancellationToken);
var learningDeliveries = preSummarisedData
.GroupBy(x => x.ReportingAimFundingLineType, StringComparer.OrdinalIgnoreCase)
.Select(ld => new LearningDelivery
{
Fundline = ld.Key,
PeriodisedData = ld.Select(pd => new PeriodisedData
{
ApprenticeshipContractType = pd.ContractType,
FundingSource = pd.FundingSource,
TransactionType = pd.TransactionType,
Periods = new List <Period>
{
new Period
{
CollectionMonth = pd.CollectionPeriod,
CollectionYear = pd.AcademicYear,
Value = pd.Amount,
},
},
}).ToList(),
}).ToList();
return(learningDeliveries);
}
}
public async Task <ICollection <SummarisedActual> > CollateAndSummariseAsync(ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
_logger.LogInfo($"Summarisation Wrapper: Retrieving Collection Periods Start");
_logger.LogInfo($"Summarisation Message: CollectionType : {summarisationMessage.CollectionType}, CollectionReturnCode: {summarisationMessage.CollectionReturnCode}, ILRCollectionYear: {summarisationMessage.CollectionYear}, ILRReturnPeriod: {summarisationMessage.CollectionMonth}");
var providerCollectionType = $"{summarisationMessage.CollectionType}{summarisationMessage.CollectionYear}";
var collectionPeriods = _collectionPeriodsProviders.Single(w => w.CollectionType.Equals(providerCollectionType, StringComparison.OrdinalIgnoreCase)).Provide();
var fundingTypeConfiguration = _fundingTypesProviders.Single(w => w.CollectionType.Equals(providerCollectionType, StringComparison.OrdinalIgnoreCase)).Provide();
_logger.LogInfo($"Summarisation Wrapper: Retrieving Collection Periods End");
_logger.LogInfo($"Summarisation Wrapper: Retrieving FCS Contracts Start");
var fcsContractAllocations = await _fcsRepository.RetrieveContractAllocationsAsync(FundingStreamConstants.FundingStreams, cancellationToken);
_logger.LogInfo($"Summarisation Wrapper: Retrieving FCS Contracts End");
var summarisedActuals = new List <SummarisedActual>();
ICollection <int> providerIdentifiers;
if (summarisationMessage.Ukprn.HasValue && summarisationMessage.Ukprn > 0)
{
providerIdentifiers = new List <int> {
summarisationMessage.Ukprn.Value
};
}
else
{
providerIdentifiers = await _repositoryFactory.Invoke().GetAllIdentifiersAsync(summarisationMessage.CollectionType, cancellationToken);
}
_logger.LogInfo($"Summarisation Wrapper: Providers to be summarised : {providerIdentifiers.Count}");
_logger.LogInfo($"Summarisation Wrapper: Retrieving Providers Data Start");
var providersData = await RetrieveProvidersData(providerIdentifiers.ToList(), summarisationMessage, cancellationToken);
_logger.LogInfo($"Summarisation Wrapper: Retrieving Providers Data End");
_logger.LogInfo($"Summarisation Wrapper: Summarisation Start");
int runningCount = 1;
int totalProviderCount = providerIdentifiers.Count;
foreach (var ukprn in providerIdentifiers)
{
_logger.LogInfo($"Summarisation Wrapper: Summarising Data of UKPRN: {ukprn} Start, {runningCount} / {totalProviderCount}");
var providerData = providersData[ukprn];
var providerActuals = await _providerSummarisationService.Summarise(providerData, collectionPeriods, fundingTypeConfiguration, fcsContractAllocations, summarisationMessage, cancellationToken);
summarisedActuals.AddRange(providerActuals);
_logger.LogInfo($"Summarisation Wrapper: Summarising Data of UKPRN: {ukprn} End, {runningCount++} / {totalProviderCount}");
}
_logger.LogInfo($"Summarisation Wrapper: Summarisation End");
return(summarisedActuals);
}
public async Task <ICollection <SummarisedActual> > Summarise(LearningProvider providerData, ICollection <CollectionPeriod> collectionPeriods, ICollection <FundingType> fundingTypes, ICollection <FcsContractAllocation> contractAllocations, ISummarisationMessage summarisationMessage, CancellationToken cancellationToken)
{
var providerActuals = new List <SummarisedActual>();
foreach (var summarisationType in summarisationMessage.SummarisationTypes)
{
_logger.LogInfo($"Summarisation Wrapper: Summarising Data of UKPRN: {providerData.UKPRN}, Fundmodel {summarisationType} Start");
var fundingStreams = fundingTypes?
.Where(x => x.SummarisationType.Equals(summarisationType, StringComparison.OrdinalIgnoreCase))
.SelectMany(fs => fs.FundingStreams)
.ToList();
var providerfundingstreamsContracts = await _providerContractsService.GetProviderContracts(providerData.UKPRN, fundingStreams, contractAllocations, cancellationToken);
var summarisedData = _summarisationService.Summarise(providerfundingstreamsContracts.FundingStreams, providerData, providerfundingstreamsContracts.FcsContractAllocations, collectionPeriods, summarisationMessage);
providerActuals.AddRange(summarisedData);
_logger.LogInfo($"Summarisation Wrapper: Summarising Data of UKPRN: {providerData.UKPRN}, Fundmodel {summarisationType} End");
}
return(providerActuals);
}
