private void AndTheSavePublishedProviderVersionResponse(HttpStatusCode httpStatusCode, PublishedProviderVersion expectedPublishedProviderVersion) { _publishedProviderVersioningService.Setup(_ => _.SaveVersion(expectedPublishedProviderVersion)) .ReturnsAsync(httpStatusCode); }
public async Task ReturnsTheCurrentPublishedProviderVersionFromEachPublishedProviderTheRepositoryFinds() { PublishedProviderVersion firstExpectedVersion = NewPublishedProviderVersion(); PublishedProviderVersion secondExpectedVersion = NewPublishedProviderVersion(); PublishedProviderVersion thirdExpectedVersion = NewPublishedProviderVersion(); GivenThePublishedProvidersForTheSpecificationId( NewPublishedProvider(_ => _.WithCurrent(firstExpectedVersion)), NewPublishedProvider(_ => _.WithCurrent(secondExpectedVersion)), NewPublishedProvider(_ => _.WithCurrent(thirdExpectedVersion))); AndTheSpecificationSummaryIsRetrieved(NewSpecificationSummary(s => { s.WithId(_specificationId); s.WithFundingPeriodId(_fundingPeriodId); s.WithFundingStreamIds(new[] { _fundingStreamId }); })); await WhenThePublishedProvidersAreQueried(); ThenTheResponseShouldBe <OkObjectResult>(_ => ((IEnumerable <PublishedProviderVersion>)_.Value).SequenceEqual(new[] { firstExpectedVersion, secondExpectedVersion, thirdExpectedVersion })); }
public Task DetermineVariations(ProviderVariationContext providerVariationContext, IEnumerable <string> fundingLineCodes) { Guard.ArgumentNotNull(providerVariationContext, nameof(providerVariationContext)); PublishedProviderVersion priorState = providerVariationContext.PriorState; if (priorState == null || priorState.Provider.Status == Closed || providerVariationContext.UpdatedProvider.Status != Closed || !providerVariationContext.UpdatedProvider.Successor.IsNullOrWhitespace()) { return(Task.CompletedTask); } if (providerVariationContext.UpdatedTotalFunding != priorState.TotalFunding) { providerVariationContext.RecordErrors("Unable to run Closure variation as TotalFunding has changed during the refresh funding"); return(Task.CompletedTask); } providerVariationContext.QueueVariationChange(new ZeroRemainingProfilesChange(providerVariationContext)); providerVariationContext.QueueVariationChange(new ZeroInitialPaymentProfilesChange(providerVariationContext)); providerVariationContext.QueueVariationChange(new ReAdjustFundingValuesForProfileValuesChange(providerVariationContext)); return(Task.CompletedTask); }
public async Task AssignProfilePatternKeyReturnsBadRequestIfNewPublishedProviderVersionCreationFailed() { string fundingLineCode = NewRandomString(); string existingProfilePatternKey = NewRandomString(); string newProfilePatterFundingKey = NewRandomString(); GivenTheFundingConfiguration(true); ProfilePatternKey profilePatternKey = NewProfilePatternKey(_ => _.WithFundingLineCode(fundingLineCode).WithKey(newProfilePatterFundingKey)); FundingLine fundingLine = NewFundingLine(_ => _.WithFundingLineCode(fundingLineCode)); PublishedProviderVersion existingPublishedProviderVersion = NewPublishedProviderVersion(ppv => ppv .WithFundingStreamId(_fundingStreamId) .WithFundingPeriodId(_fundingPeriodId) .WithProfilePatternKeys( NewProfilePatternKey(_ => _.WithFundingLineCode(fundingLineCode).WithKey(existingProfilePatternKey))) .WithFundingLines(fundingLine) ); PublishedProvider publishedProvider = NewPublishedProvider(_ => _.WithCurrent(existingPublishedProviderVersion)); GivenThePublishedProvider(publishedProvider); IActionResult result = await WhenProfilePatternKeyIsAssigned(_fundingStreamId, _fundingPeriodId, _providerId, profilePatternKey); ThenResultShouldBe(result, HttpStatusCode.BadRequest); }
public async Task GetLatestEarlierPublishedProviderVersion() { string fundingStreamId = NewRandomString(); string fundingPeriodId = NewRandomString(); long timeStamp = NewRandomTimeStamp(); string providerId = NewRandomString(); PublishedProviderVersion expectedLatestEarlierDocument = NewPublishedProviderVersion(); GivenTheLatestEarlierDocument(@$ "SELECT TOP 1 * FROM publishedProviderVersion p WHERE p.documentType = 'PublishedProviderVersion' AND p._ts < @sinceTimeStamp AND p.content.fundingStreamId = @fundingStreamId AND p.content.fundingPeriodId = @fundingPeriodId AND p.content.providerId = @providerId {string.Empty} AND p.deleted = false ORDER BY p._ts DESC", expectedLatestEarlierDocument, ("@fundingPeriodId", fundingPeriodId), ("@fundingStreamId", fundingStreamId), ("@sinceTimeStamp", timeStamp), ("@providerId", providerId)); PublishedProviderVersion actualLatestEarlierDocument = await _repository.GetLatestEarlierPublishedProviderVersion(fundingStreamId, fundingPeriodId, timeStamp, providerId); actualLatestEarlierDocument .Should() .BeSameAs(expectedLatestEarlierDocument); }
public async Task GetLatestEarlierPublishedProviderVersionFromVersion() { string fundingStreamId = NewRandomString(); string fundingPeriodId = NewRandomString(); decimal version = NewRandomInteger(); string providerId = NewRandomString(); PublishedProviderVersion expectedLatestEarlierDocument = NewPublishedProviderVersion(); GivenTheLatestEarlierDocument(@$ "SELECT TOP 1 * FROM publishedProviderVersion p WHERE p.documentType = 'PublishedProviderVersion' AND StringToNumber(CONCAT(Tostring(p.content.majorVersion), '.', Tostring(p.content.minorVersion))) < @version AND p.content.fundingStreamId = @fundingStreamId AND p.content.fundingPeriodId = @fundingPeriodId AND p.content.providerId = @providerId {string.Empty} AND p.deleted = false ORDER BY p.content.majorVersion DESC, p.content.minorVersion DESC", expectedLatestEarlierDocument, ("@fundingPeriodId", fundingPeriodId), ("@fundingStreamId", fundingStreamId), ("@version", version), ("@providerId", providerId)); PublishedProviderVersion actualLatestEarlierDocument = await _repository.GetLatestEarlierPublishedProviderVersionFromVersion(fundingStreamId, fundingPeriodId, version, providerId); actualLatestEarlierDocument .Should() .BeSameAs(expectedLatestEarlierDocument); }
private bool HasNoPaidPeriods(ProviderVariationContext providerVariationContext, PublishedProviderVersion priorState) { foreach (ProfileVariationPointer variationPointer in providerVariationContext.VariationPointers ?? ArraySegment <ProfileVariationPointer> .Empty) { FundingLine fundingLine = priorState?.FundingLines.SingleOrDefault(_ => _.FundingLineCode == variationPointer.FundingLineId); if (fundingLine == null) { continue; } YearMonthOrderedProfilePeriods periods = new YearMonthOrderedProfilePeriods(fundingLine); int variationPointerIndex = periods.IndexOf(_ => _.Occurrence == variationPointer.Occurrence && _.Type.ToString() == variationPointer.PeriodType && _.Year == variationPointer.Year && _.TypeValue == variationPointer.TypeValue); if (variationPointerIndex > 0) { return(false); } } return(true); }
public async Task GetsPublishedProviderTransactionForSuppliedSpecificationAndProvider() { PublishedProviderVersion publishedProviderVersion = NewPublishedProviderVersion(_ => _.WithAuthor(new Reference { Id = Guid.NewGuid().ToString() }) .WithFundingLines(NewFundingLine())); AndThePublishedFundingRepositoryReturnsPublishedProviderVersions(publishedProviderVersion); await WhenGetPublishedProviderTransactionsIsCalled(publishedProviderVersion); PublishedProviderTransaction[] expectedPublishedProviderTransaction = { NewPublishedProviderTransaction(_ => _.WithAuthor(publishedProviderVersion.Author) .WithPublishedProviderId(publishedProviderVersion.PublishedProviderId) .WithDate(publishedProviderVersion.Date) .WithPublishedProviderStatus(publishedProviderVersion.Status) .WithTotalFunding(publishedProviderVersion.TotalFunding) .WithFundingLines(publishedProviderVersion.FundingLines.ToArray())) }; ActionResult .Should() .BeOfType <OkObjectResult>() .Which .Value .Should() .BeEquivalentTo(expectedPublishedProviderTransaction); }
public void ThrowsExceptionWhenContentGeneratorReturnsNull() { // Arrange TemplateMetadataContents templateMetadataContents = Substitute.For <TemplateMetadataContents>(); TemplateMapping templateMapping = Substitute.For <TemplateMapping>(); IPublishedProviderContentsGenerator publishedProviderContentsGenerator = Substitute.For <IPublishedProviderContentsGenerator>(); Dictionary <string, GeneratedProviderResult> generatedPublishedProviderData = new Dictionary <string, GeneratedProviderResult>(); List <PublishedProvider> publishedProvidersToUpdate = new List <PublishedProvider>(); GeneratedProviderResult generatedProviderResult = new GeneratedProviderResult(); PublishedProviderVersion publishedProviderVersion = NewPublishedProviderVersion(providerVersion => providerVersion .WithProviderId(ProviderVersionProviderId) .WithFundingPeriodId(ProviderVersionFundingPeriodId) .WithFundingStreamId(ProviderVersionFundingStreamId) .WithVersion(ProviderVersionVersion)); PublishedProvider publishedProvider = NewPublishedProvider(provider => provider.WithCurrent(publishedProviderVersion)); generatedPublishedProviderData.Add(key, generatedProviderResult); publishedProvidersToUpdate.Add(publishedProvider); // Act Func <Task> invocation = async() => await _publishedProviderContentPersistanceService.SavePublishedProviderContents( templateMetadataContents, templateMapping, publishedProvidersToUpdate, publishedProviderContentsGenerator); // Assert ThenExceptionShouldBeThrown($"Generator failed to generate content for published provider version with id: '{publishedProviderVersion.Id}'", invocation); }
public PaymentFundingLineProfileTotals( PublishedProviderVersion publishedProviderVersion, string fundingLineId) { _profileTotals = publishedProviderVersion .FundingLines.Where(_ => _.Type == FundingLineType.Payment) .Where(_ => _.FundingLineCode == fundingLineId) .SelectMany(paymentFundingLine => new YearMonthOrderedProfilePeriods(paymentFundingLine)) .GroupBy(orderProfilePeriod => new { orderProfilePeriod.Year, orderProfilePeriod.TypeValue, orderProfilePeriod.Occurrence, orderProfilePeriod.DistributionPeriodId }) .Select(grouping => new ProfileTotal { Occurrence = grouping.Key.Occurrence, Year = grouping.Key.Year, TypeValue = grouping.Key.TypeValue, Value = grouping.Sum(profilePeriod => profilePeriod.ProfiledValue), PeriodType = grouping.FirstOrDefault().Type.ToString(), DistributionPeriodId = grouping.Key.DistributionPeriodId }) .ToArray(); }
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; } }
public async Task DeletesCosmosDocumentsAndMatchingBlobStoreDocumentsForFeedItems() { PublishedProviderVersion publishedProviderVersionOne = NewPublishedProviderVersion(); PublishedProviderVersion publishedProviderVersionTwo = NewPublishedProviderVersion(); PublishedProviderVersion publishedProviderVersionThree = NewPublishedProviderVersion(); PublishedProviderVersion publishedProviderVersionFour = NewPublishedProviderVersion(); GivenThePublishedProviderVersionFeed(NewFeedIterator( WithPages(Page(publishedProviderVersionOne, publishedProviderVersionTwo), Page <PublishedProviderVersion>(), Page(publishedProviderVersionThree, publishedProviderVersionFour)))); await WhenTheTaskIsRun(); ThenTheDocumentsWereDeleted(new [] { publishedProviderVersionOne, publishedProviderVersionTwo }, new [] { publishedProviderVersionOne.PartitionKey, publishedProviderVersionTwo.PartitionKey }, true); AndTheDocumentsWereDeleted(new [] { publishedProviderVersionThree, publishedProviderVersionFour }, new [] { publishedProviderVersionThree.PartitionKey, publishedProviderVersionFour.PartitionKey }, true); AndThePublishedProviderVersionBlobDocumentsWereRemoved(publishedProviderVersionOne, publishedProviderVersionTwo, publishedProviderVersionThree, publishedProviderVersionFour); }
private void PublishProviderDocument(FeedOptions options, PublishedProviderVersion publishedProviderVersion, string generatedDocumentContent) { if (options.FeedStorageType == FeedStorageType.File) { File.WriteAllText(Path.Combine(options.OutputFolderPath, $"{publishedProviderVersion.FundingId}.json"), generatedDocumentContent); } }
private static PublishedProviderFundingStructureItem RecursivelyAddFundingLines( IEnumerable <Common.TemplateMetadata.Models.FundingLine> fundingLines, List <TemplateMappingItem> templateMappingItems, int level, Common.TemplateMetadata.Models.FundingLine fundingLine, PublishedProviderVersion publishedProviderVersion) { level++; List <PublishedProviderFundingStructureItem> innerFundingStructureItems = new List <PublishedProviderFundingStructureItem>(); // If funding line has calculations, recursively add them to list of inner FundingStructureItems if (fundingLine.Calculations != null && fundingLine.Calculations.Any()) { foreach (Common.TemplateMetadata.Models.Calculation calculation in fundingLine.Calculations) { innerFundingStructureItems.Add( RecursivelyMapCalculationsToFundingStructureItem( calculation, level, templateMappingItems, publishedProviderVersion)); } } // If funding line has more funding lines, recursively add them to list of inner FundingStructureItems if (fundingLine.FundingLines != null && fundingLine.FundingLines.Any()) { foreach (Common.TemplateMetadata.Models.FundingLine line in fundingLines) { innerFundingStructureItems.Add(RecursivelyAddFundingLines( line.FundingLines, templateMappingItems, level, line, publishedProviderVersion)); } } CalculateFunding.Models.Publishing.FundingLine publishedProviderFundingLine = publishedProviderVersion.FundingLines.FirstOrDefault(_ => _.TemplateLineId == fundingLine.TemplateLineId); string calculationValue = null; if (publishedProviderFundingLine != null) { calculationValue = publishedProviderFundingLine.Value.AsFormatCalculationType(CalculationValueFormat.Currency); } // Add FundingStructureItem PublishedProviderFundingStructureItem fundingStructureItem = MapToFundingStructureItem( level, fundingLine.Name, fundingLine.FundingLineCode, PublishedProviderFundingStructureType.FundingLine, null, null, innerFundingStructureItems.Any() ? innerFundingStructureItems : null, calculationValue); return(fundingStructureItem); }
public async Task <PublishedProvider> CreateMissingPublishedProviderForPredecessor(PublishedProvider predecessor, string successorId, string providerVersionId) { ApiResponse <ProviderVersionSearchResult> apiResponse = await _providersApiClientPolicy.ExecuteAsync(() => _providersApiClient.GetProviderByIdFromProviderVersion(providerVersionId, successorId)); ProviderVersionSearchResult providerVersionSearchResult = apiResponse?.Content; if (providerVersionSearchResult == null) { return(null); } PublishedProviderVersion predecessorProviderVersion = predecessor.Current; PublishedProvider missingProvider = CreatePublishedProvider(_mapper.Map <Provider>(providerVersionSearchResult), predecessorProviderVersion.FundingPeriodId, predecessorProviderVersion.FundingStreamId, predecessorProviderVersion.SpecificationId, "Created by the system as not in scope but referenced as a successor provider", predecessorProviderVersion.FundingLines.DeepCopy(), predecessorProviderVersion.Calculations.DeepCopy()); foreach (ProfilePeriod profilePeriod in missingProvider.Current.FundingLines.SelectMany(_ => _.DistributionPeriods.SelectMany(dp => dp.ProfilePeriods))) { profilePeriod.ProfiledValue = 0; } return(missingProvider); }
protected override Task <ErrorCheck> HasErrors(PublishedProvider publishedProvider, PublishedProvidersContext publishedProvidersContext) { ErrorCheck errorCheck = new ErrorCheck(); PublishedProviderVersion publishedProviderVersion = publishedProvider.Current; foreach (FundingLine fundingLine in CustomPaymentFundingLinesFor(publishedProviderVersion)) { decimal fundingLineValue = fundingLine.Value.GetValueOrDefault(); decimal profiledValue = GetProfiledSum(fundingLine, publishedProviderVersion); if (fundingLineValue != profiledValue) { errorCheck.AddError(new PublishedProviderError { Identifier = fundingLine.FundingLineCode, Type = PublishedProviderErrorType.FundingLineValueProfileMismatch, SummaryErrorMessage = "A funding line profile doesn't match allocation value.", DetailedErrorMessage = $"Funding line profile doesn't match allocation value. " + $"The allocation value is £{fundingLineValue}, but the profile value is set to £{profiledValue}", FundingLineCode = fundingLine.FundingLineCode, FundingStreamId = publishedProviderVersion.FundingStreamId }); } } return(Task.FromResult(errorCheck)); }
protected virtual bool HasNoProfilingChanges(PublishedProviderVersion priorState, PublishedProviderVersion refreshState, ProviderVariationContext providerVariationContext) { IDictionary <string, FundingLine> latestFundingLines = refreshState.FundingLines.Where(_ => _.Type == FundingLineType.Payment) .ToDictionary(_ => _.FundingLineCode); bool hasNoProfilingChanges = true; foreach (FundingLine previousFundingLine in priorState.FundingLines.Where(_ => _.Type == FundingLineType.Payment && _.Value.HasValue && ExtraFundingLinePredicate(refreshState, _))) { string fundingLineCode = previousFundingLine.FundingLineCode; if (!latestFundingLines.TryGetValue(fundingLineCode, out FundingLine latestFundingLine)) { continue; } ProfilePeriod[] priorProfiling = new YearMonthOrderedProfilePeriods(previousFundingLine).ToArray(); ProfilePeriod[] latestProfiling = new YearMonthOrderedProfilePeriods(latestFundingLine).ToArray(); if (!priorProfiling.Select(AsLiteral) .SequenceEqual(latestProfiling.Select(AsLiteral))) { providerVariationContext.AddAffectedFundingLineCode(fundingLineCode); hasNoProfilingChanges = false; } } return(hasNoProfilingChanges); }
public async Task <PublishedProvider> CreateVersion(PublishedProviderCreateVersionRequest publishedProviderCreateVersionRequest) { Guard.ArgumentNotNull(publishedProviderCreateVersionRequest.PublishedProvider, nameof(publishedProviderCreateVersionRequest.PublishedProvider)); Guard.ArgumentNotNull(publishedProviderCreateVersionRequest.NewVersion, nameof(publishedProviderCreateVersionRequest.NewVersion)); PublishedProviderVersion currentVersion = publishedProviderCreateVersionRequest.PublishedProvider.Current; PublishedProviderVersion newVersion = publishedProviderCreateVersionRequest.NewVersion; string partitionKey = currentVersion != null ? publishedProviderCreateVersionRequest.PublishedProvider.PartitionKey : string.Empty; try { publishedProviderCreateVersionRequest.PublishedProvider.Current = await _versionRepositoryPolicy.ExecuteAsync(() => _versionRepository.CreateVersion(newVersion, currentVersion, partitionKey)); } catch (Exception ex) { _logger.Error(ex, $"Failed to create new version for published provider version id: {newVersion.Id}"); throw; } return(publishedProviderCreateVersionRequest.PublishedProvider); }
public void ProcessPublishedProvider(PublishedProviderVersion publishedProviderVersion) { Guard.ArgumentNotNull(publishedProviderVersion, nameof(publishedProviderVersion)); if (!publishedProviderVersion.HasCustomProfiles) { return; } Dictionary <string, FundingLine> fundingLines = publishedProviderVersion.FundingLines?.Where(_ => _.Type == FundingLineType.Payment)?.ToDictionary(_ => _.FundingLineCode) ?? new Dictionary <string, FundingLine>(); foreach (FundingLineProfileOverrides customProfile in publishedProviderVersion.CustomProfiles) { string fundingLineCode = customProfile.FundingLineCode; if (!fundingLines.TryGetValue(fundingLineCode, out FundingLine fundingLine)) { throw new InvalidOperationException( $"Custom profile has no matching funding line for {fundingLineCode} on {publishedProviderVersion.Id}"); } fundingLine.DistributionPeriods = customProfile.DistributionPeriods.DeepCopy(); } }
public Task <HttpStatusCode> UpsertAsync <T>(T entity, string partitionKey = null, bool undelete = false, bool maintainCreatedDate = true) where T : IIdentifiable { if (typeof(T).Name == "PublishedProviderVersion") { PublishedProviderVersion publishedProviderVersion = entity as PublishedProviderVersion; if (!PublishedProviderVersions.ContainsKey(publishedProviderVersion.SpecificationId)) { PublishedProviderVersions.TryAdd(publishedProviderVersion.SpecificationId, new ConcurrentDictionary <string, PublishedProviderVersion>()); } PublishedProviderVersions[publishedProviderVersion.SpecificationId][publishedProviderVersion.Id] = publishedProviderVersion; return(Task.FromResult(HttpStatusCode.OK)); } else if (typeof(T).Name == "PublishedFundingVersion") { PublishedFundingVersion publishedFundingVersion = entity as PublishedFundingVersion; if (!PublishedFundingVersions.ContainsKey(publishedFundingVersion.SpecificationId)) { PublishedFundingVersions.TryAdd(publishedFundingVersion.SpecificationId, new ConcurrentDictionary <string, PublishedFundingVersion>()); } PublishedFundingVersions[publishedFundingVersion.SpecificationId][publishedFundingVersion.Id] = publishedFundingVersion; return(Task.FromResult(HttpStatusCode.OK)); } return(Task.FromResult(HttpStatusCode.BadRequest)); }
private PublishedProviderIndex CreatePublishedProviderIndex(PublishedProviderVersion publishedProviderVersion) => new PublishedProviderIndex { Id = publishedProviderVersion.PublishedProviderId, ProviderType = publishedProviderVersion.Provider.ProviderType, ProviderSubType = publishedProviderVersion.Provider.ProviderSubType, LocalAuthority = publishedProviderVersion.Provider.Authority, FundingStatus = publishedProviderVersion.Status.ToString(), ProviderName = publishedProviderVersion.Provider.Name, UKPRN = publishedProviderVersion.Provider.UKPRN, FundingValue = Convert.ToDouble(publishedProviderVersion.TotalFunding), SpecificationId = publishedProviderVersion.SpecificationId, FundingStreamId = publishedProviderVersion.FundingStreamId, FundingPeriodId = publishedProviderVersion.FundingPeriodId, HasErrors = publishedProviderVersion.HasErrors, UPIN = publishedProviderVersion.Provider.UPIN, URN = publishedProviderVersion.Provider.URN, Errors = publishedProviderVersion.Errors != null?publishedProviderVersion .Errors .Select(_ => _.SummaryErrorMessage) .Where(_ => !string.IsNullOrEmpty(_)) .Distinct() .ToArraySafe() : Array.Empty <string>() };
public async Task GetFundingStructure_GivenNoSpecificationFoundForPublishedProviderVersion_ReturnsNotFound() { string publishedProviderVersionId = NewRandomString(); string specificationId = NewRandomString(); string fundingPeriodId = NewRandomString(); string providerId = NewRandomString(); string fundingStreamId = NewRandomString(); int templateVersion = NewRandomNumber(); PublishedProviderVersion publishedProviderVersion = NewPublishedProviderVersion(_ => _ .WithFundingStreamId(fundingStreamId) .WithFundingPeriodId(fundingPeriodId) .WithProviderId(providerId) .WithSpecificationId(specificationId)); _publishedFundingRepository.GetPublishedProviderVersionById(publishedProviderVersionId) .Returns(publishedProviderVersion); _specificationService.GetSpecificationSummaryById(specificationId) .Returns((SpecificationSummary)null); var result = await _service.GetPublishedProviderFundingStructure(publishedProviderVersionId); NotFoundObjectResult notFoundObjectResult = result.Should() .BeAssignableTo <NotFoundObjectResult>() .Which .As <NotFoundObjectResult>(); notFoundObjectResult.Value .Should() .Be($"Specification not found for SpecificationId - {specificationId}"); }
public void UpdatesGeneratedResultIfPreviousVersionFundingLineIsPresent() { uint templateLineId = NewRandomUint(); FundingLine generatedResultFundingLine = NewFundingLine(fl => fl .WithTemplateLineId(templateLineId) .WithFundingLineType(FundingLineType.Payment)); GeneratedProviderResult generatedProviderResult = NewGeneratedProviderResult(_ => _.WithFundlines(NewFundingLine(fl => fl .WithTemplateLineId(templateLineId) .WithFundingLineType(FundingLineType.Payment)))); PublishedProviderVersion publishedProviderVersion = NewPublishedProviderVersion(_ => _.WithFundingLines(NewFundingLine(fl => fl.WithTemplateLineId(templateLineId) .WithValue(98990M)))); bool hasZeroedFundingLine = _fundingLineValueOverride.TryOverridePreviousFundingLineValues(publishedProviderVersion, generatedProviderResult); hasZeroedFundingLine .Should() .BeTrue(); generatedResultFundingLine.Value .Should() .BeNull(); }
protected override void GivenTheOtherwiseValidVariationContext(Action <ProviderVariationContext> changes = null) { base.GivenTheOtherwiseValidVariationContext(changes); PublishedProvider publishedProvider = VariationContext.GetPublishedProviderOriginalSnapShot(VariationContext.ProviderId); if (publishedProvider == null) { return; } PublishedProviderVersion publishedProviderCurrent = publishedProvider.Current; publishedProviderCurrent.FundingLines = new[] { NewFundingLine(_ => _.WithFundingLineCode(FundingLineCode) .WithFundingLineType(FundingLineType.Payment) .WithValue(new RandomNumberBetween(1, int.MaxValue)) .WithDistributionPeriods(NewDistributionPeriod(dp => dp.WithProfilePeriods(NewProfilePeriod())))) }; publishedProviderCurrent.Provider = NewProvider(); publishedProvider.Released = publishedProviderCurrent.DeepCopy(); }
public async Task GetFundingStructure_GivenNoTemplateVersionForFundingStream_ReturnsServerError() { string publishedProviderVersionId = NewRandomString(); string specificationId = NewRandomString(); string fundingPeriodId = NewRandomString(); string providerId = NewRandomString(); string fundingStreamId = NewRandomString(); int templateVersion = NewRandomNumber(); PublishedProviderVersion publishedProviderVersion = NewPublishedProviderVersion(_ => _ .WithFundingStreamId(fundingStreamId) .WithFundingPeriodId(fundingPeriodId) .WithProviderId(providerId) .WithSpecificationId(specificationId)); SpecificationSummary specificationSummary = NewSpecificationSummary(_ => _.WithId(specificationId)); _publishedFundingRepository.GetPublishedProviderVersionById(publishedProviderVersionId) .Returns(publishedProviderVersion); _specificationService.GetSpecificationSummaryById(specificationId) .Returns(specificationSummary); var result = await _service.GetPublishedProviderFundingStructure(publishedProviderVersionId); InternalServerErrorResult notFoundObjectResult = result.Should() .BeAssignableTo <InternalServerErrorResult>() .Which .As <InternalServerErrorResult>(); notFoundObjectResult.Value .Should() .Be($"Specification contains no matching template version for funding stream '{fundingStreamId}'"); }
public void SetUp() { _fundingStreamId = NewRandomString(); _fundingPeriodId = NewRandomString(); _templateVersion = NewRandomString(); _cacheKey = $"PupilNumberTemplateCalculationIds:{_fundingStreamId}:{_fundingPeriodId}:{_templateVersion}"; PublishedProviderVersion refreshState = VariationContext.RefreshState; refreshState.FundingStreamId = _fundingStreamId; refreshState.TemplateVersion = _templateVersion; refreshState.FundingPeriodId = _fundingPeriodId; _caching = new Mock <ICacheProvider>(); _policies = new Mock <IPoliciesApiClient>(); VariationsApplication.CacheProvider .Returns(_caching.Object); VariationsApplication.PoliciesApiClient .Returns(_policies.Object); Change = new MovePupilNumbersToSuccessorChange(VariationContext); VariationContext.SuccessorRefreshState = VariationContext.RefreshState.DeepCopy(); }
private async Task ProfileFundingLineValues(PublishedProviderVersion newPublishedProviderVersion, ProfilePatternKey profilePatternKey) { string fundingLineCode = profilePatternKey.FundingLineCode; FundingLine fundingLine = newPublishedProviderVersion.FundingLines.SingleOrDefault(_ => _.FundingLineCode == fundingLineCode); if (fundingLine == null) { string error = $"Did not locate a funding line with code {fundingLineCode} on published provider version {newPublishedProviderVersion.PublishedProviderId}"; _logger.Error(error); throw new InvalidOperationException(error); } ApiResponse <IEnumerable <ProfileVariationPointer> > variationPointersResponse = await _specificationResiliencePolicy.ExecuteAsync(() => _specificationsApiClient.GetProfileVariationPointers(newPublishedProviderVersion.SpecificationId)); IEnumerable <ProfileVariationPointer> profileVariationPointers = variationPointersResponse? .Content? .Where(_ => _.FundingLineId == fundingLineCode && _.FundingStreamId == newPublishedProviderVersion.FundingStreamId); if (ThereArePaidProfilePeriodsOnTheFundingLine(profileVariationPointers)) { await ReProfileFundingLine(newPublishedProviderVersion, profilePatternKey, fundingLineCode, fundingLine); } else { await ProfileFundingLine(fundingLine, newPublishedProviderVersion, profilePatternKey); } }
private async Task WhenGetPublishedProviderVersionIsCalled(PublishedProviderVersion publishedProviderVersion) { ActionResult = await _service.GetPublishedProviderVersion(publishedProviderVersion.FundingStreamId, publishedProviderVersion.FundingPeriodId, publishedProviderVersion.ProviderId, publishedProviderVersion.Version.ToString()); }
private async Task ProfileFundingLine(FundingLine fundingLine, PublishedProviderVersion newPublishedProviderVersion, ProfilePatternKey profilePatternKey) { await _profilingService.ProfileFundingLines( new[] { fundingLine }, newPublishedProviderVersion.FundingStreamId, newPublishedProviderVersion.FundingPeriodId, new[] { profilePatternKey }); }
private void AndTheApiResponseDetailsForCurrentPublishedVersionMetaSupplied( PublishedProviderVersion publishedProviderVersion) { _publishedFundingRepository.GetLatestPublishedProviderVersionBySpecificationId(publishedProviderVersion?.SpecificationId, publishedProviderVersion?.FundingStreamId, publishedProviderVersion?.ProviderId) .Returns(publishedProviderVersion); }