protected override async Task ApplyChanges(IApplyProviderVariations variationsApplications)
{
Guard.ArgumentNotNull(variationsApplications, nameof(variationsApplications));
PublishedProviderVersion predecessor = RefreshState;
string fundingStreamId = predecessor.FundingStreamId;
string fundingPeriodId = predecessor.FundingPeriodId;
string templateVersion = predecessor.TemplateVersion;
IEnumerable <uint> pupilNumberTemplateCalculationIds = await new PupilNumberCalculationIdProvider(variationsApplications)
.GetPupilNumberCalculationIds(fundingStreamId, fundingPeriodId, templateVersion);
Dictionary <uint, FundingCalculation> predecessorCalculations = predecessor
.Calculations
.ToDictionary(_ => _.TemplateCalculationId);
Dictionary <uint, FundingCalculation> successorCalculations = SuccessorRefreshState
.Calculations
.ToDictionary(_ => _.TemplateCalculationId);
foreach (uint templateCalculationId in pupilNumberTemplateCalculationIds)
{
if (!predecessorCalculations.TryGetValue(templateCalculationId, out FundingCalculation predecessorCalculation) ||
!successorCalculations.TryGetValue(templateCalculationId, out FundingCalculation successorCalculation))
{
throw new InvalidOperationException("Cannot move pupil numbers to successor.\n" +
$"Could not locate both FundingCalculations for id {templateCalculationId}");
}
int totalPupilNumber = Convert.ToInt32(successorCalculation.Value) + Convert.ToInt32(predecessorCalculation.Value);
successorCalculation.Value = totalPupilNumber;
}
}
protected override Task ApplyChanges(IApplyProviderVariations variationsApplications)
{
AdjustDistributionPeriodValuesForProfileAmountChanges();
AdjustFundingLineValuesForDistributionPeriodValueChanges();
AdjustTotalFundingForProviderForFundingLineValueChanges();
return(Task.CompletedTask);
}
public virtual async Task ApplyVariationChanges(IApplyProviderVariations variationsApplication)
{
while (_variationChanges.Count > 0)
{
IVariationChange variationChange = _variationChanges.Dequeue();
await variationChange.Apply(variationsApplication);
}
}
public VariationServiceStepContext(IDetectProviderVariations variationsDetection,
IApplyProviderVariations variationsApplication,
ISpecificationsApiClient specificationsApiClient)
{
_specificationsApiClient = specificationsApiClient;
Guard.ArgumentNotNull(variationsApplication, nameof(variationsApplication));
Guard.ArgumentNotNull(variationsDetection, nameof(variationsDetection));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
VariationsDetection = variationsDetection;
VariationsApplication = variationsApplication;
}
protected override async Task ApplyChanges(IApplyProviderVariations variationsApplications)
{
Guard.IsNotEmpty(VariationContext.AffectedFundingLineCodes, nameof(VariationContext.AffectedFundingLineCodes));
PublishedProviderVersion refreshState = RefreshState;
Task[] reProfileTasks = VariationContext.AffectedFundingLineCodes?.Select(_ =>
ReProfileFundingLine(_, refreshState, variationsApplications))
.ToArray();
await TaskHelper.WhenAllAndThrow(reProfileTasks);
}
protected override Task ApplyChanges(IApplyProviderVariations variationsApplications)
{
RefreshState.FundingLines.Where(_ => _.Type == FundingLineType.Payment).ToList().ForEach(fl =>
{
fl.Value = 0;
fl.DistributionPeriods?
.SelectMany(_ => _.ProfilePeriods ?? new ProfilePeriod[0])
.ToList()
.ForEach(_ => _.ProfiledValue = 0);
});
return(Task.CompletedTask);
}
public PupilNumberCalculationIdProvider(IApplyProviderVariations variationsApplication)
{
IPublishingResiliencePolicies resiliencePolicies = variationsApplication.ResiliencePolicies;
Guard.ArgumentNotNull(variationsApplication.CacheProvider, nameof(variationsApplication.CacheProvider));
Guard.ArgumentNotNull(variationsApplication.PoliciesApiClient, nameof(variationsApplication.PoliciesApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.CacheProvider, nameof(resiliencePolicies.CacheProvider));
Guard.ArgumentNotNull(resiliencePolicies?.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
_policiesResilience = resiliencePolicies.PoliciesApiClient;
_cachingResilience = resiliencePolicies.CacheProvider;
_policies = variationsApplication.PoliciesApiClient;
_caching = variationsApplication.CacheProvider;
}
public VariationService(IDetectProviderVariations detectProviderVariations,
IApplyProviderVariations applyProviderVariations,
IRecordVariationErrors recordVariationErrors,
ILogger logger)
{
Guard.ArgumentNotNull(detectProviderVariations, nameof(detectProviderVariations));
Guard.ArgumentNotNull(applyProviderVariations, nameof(applyProviderVariations));
Guard.ArgumentNotNull(recordVariationErrors, nameof(recordVariationErrors));
Guard.ArgumentNotNull(logger, nameof(logger));
_detectProviderVariations = detectProviderVariations;
_applyProviderVariations = applyProviderVariations;
_recordVariationErrors = recordVariationErrors;
_logger = logger;
_snapshots = new ConcurrentDictionary <string, IDictionary <string, PublishedProviderSnapShots> >();
}
public void VariationChangeTestBaseSetUp()
{
_specificationsApiClient = Substitute.For <ISpecificationsApiClient>();
VariationsApplication = Substitute.For <IApplyProviderVariations>();
VariationsApplication.SpecificationsApiClient
.Returns(_specificationsApiClient);
VariationsApplication.ResiliencePolicies
.Returns(new ResiliencePolicies
{
SpecificationsApiClient = Policy.NoOpAsync(),
CacheProvider = Policy.NoOpAsync(),
PoliciesApiClient = Policy.NoOpAsync(),
CalculationsApiClient = Policy.NoOpAsync(),
ProfilingApiClient = Policy.NoOpAsync()
});
}
protected override Task ApplyChanges(IApplyProviderVariations variationsApplications)
{
try
{
IEnumerable <ProfileVariationPointer> variationPointers = VariationContext.VariationPointers;
if (variationPointers.IsNullOrEmpty())
{
foreach (FundingLine fl in RefreshState.FundingLines)
{
if (fl.Value.HasValue)
{
fl.Value = 0;
}
if (fl.Type == FundingLineType.Payment)
{
if (fl.DistributionPeriods != null)
{
foreach (DistributionPeriod distributionPeriod in fl.DistributionPeriods)
{
if (distributionPeriod != null)
{
foreach (ProfilePeriod profile in distributionPeriod.ProfilePeriods)
{
if (profile != null)
{
profile.ProfiledValue = 0;
}
}
}
}
}
}
}
}
}
catch (Exception exception)
{
RecordErrors($"Unable to {ChangeName} for provider id {VariationContext.ProviderId}. {exception.Message}");
}
return(Task.CompletedTask);
}
protected override Task ApplyChanges(IApplyProviderVariations variationsApplications)
{
try
{
IEnumerable <ProfileVariationPointer> variationPointers = VariationContext.VariationPointers;
if (!variationPointers.IsNullOrEmpty())
{
foreach (ProfileVariationPointer variationPointer in variationPointers)
{
MakeAdjustmentsFromProfileVariationPointer(variationPointer);
}
}
}
catch (Exception exception)
{
RecordErrors($"Unable to {_changeName} for provider id {VariationContext.ProviderId}. {exception.Message}");
}
return(Task.CompletedTask);
}
private async Task ReProfileFundingLine(string fundingLineCode,
PublishedProviderVersion refreshState,
IApplyProviderVariations variationApplications)
{
FundingLine fundingLine = refreshState.FundingLines.SingleOrDefault(_ => _.FundingLineCode == fundingLineCode);
string providerId = refreshState.ProviderId;
if (fundingLine == null)
{
throw new NonRetriableException($"Could not locate funding line {fundingLineCode} for published provider version {providerId}");
}
ReProfileRequest reProfileRequest = await variationApplications.ReProfilingRequestBuilder.BuildReProfileRequest(refreshState.SpecificationId,
refreshState.FundingStreamId,
refreshState.FundingPeriodId,
providerId,
fundingLineCode,
null,
ProfileConfigurationType.RuleBased,
fundingLine.Value);
ReProfileResponse reProfileResponse = (await variationApplications.ResiliencePolicies.ProfilingApiClient.ExecuteAsync(()
=> variationApplications.ProfilingApiClient.ReProfile(reProfileRequest)))?.Content;
if (reProfileResponse == null)
{
throw new NonRetriableException($"Could not re profile funding line {fundingLineCode} for provider {providerId}");
}
IEnumerable <DistributionPeriod> distributionPeriods = variationApplications.ReProfilingResponseMapper.MapReProfileResponseIntoDistributionPeriods(reProfileResponse);
foreach (DistributionPeriod distributionPeriod in distributionPeriods)
{
refreshState.UpdateDistributionPeriodForFundingLine(fundingLineCode,
distributionPeriod.DistributionPeriodId,
distributionPeriod.ProfilePeriods);
}
}
protected override Task ApplyChanges(IApplyProviderVariations variationsApplications)
{
RefreshState.VariationReasons = VariationContext.VariationReasons.ToArray();
return(Task.CompletedTask);
}
public void SetUp()
{
_variationContext = new ProviderVariationContext();
_applyProviderVariations = Substitute.For <IApplyProviderVariations>();
}
protected abstract Task ApplyChanges(IApplyProviderVariations variationsApplications);
public async Task Apply(IApplyProviderVariations variationsApplication)
{
await ApplyChanges(variationsApplication);
variationsApplication.AddPublishedProviderToUpdate(VariationContext.PublishedProvider);
}
