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); }