private void AndTheSpecificationSummaryIsRetrieved(SpecificationSummary specificationSummary)
{
_specificationSummary = specificationSummary;
_specificationService
.GetSpecificationSummaryById(Arg.Is(_specificationId))
.Returns(_specificationSummary);
}
public void ReturnsErrorMessageWhenSpecificationHasNoScopedProviders()
{
// Arrange
string specificationId = "specId01";
SpecificationSummary specificationSummary = new SpecificationSummary {
Id = specificationId, ApprovalStatus = PublishStatus.Approved
};
string errorMessage = "Specification failed refresh prerequisite check. Reason: no scoped providers";
// Act
Func <Task> invocation
= () => WhenThePreRequisitesAreChecked(specificationSummary, Enumerable.Empty <PublishedProvider>(), Enumerable.Empty <Provider>());
// Assert
invocation
.Should()
.Throw <JobPrereqFailedException>()
.Where(_ =>
_.Message == $"Specification with id: '{specificationSummary.Id} has prerequisites which aren't complete.");
_logger
.Received()
.Error(errorMessage);
}
private IDictionary <string, PublishedProvider> WhenGenerateMissingProviders(IEnumerable <Provider> scopedProviders,
SpecificationSummary specification,
Reference fundingStream,
IDictionary <string, PublishedProvider> publishedProviders)
{
return(_providerService.GenerateMissingPublishedProviders(scopedProviders, specification, fundingStream, publishedProviders));
}
public async Task <IActionResult> GetLatestPublishedProvidersForSpecificationId(string specificationId)
{
ValidationResult validationResults = _validator.Validate(specificationId);
if (!validationResults.IsValid)
{
return(validationResults.AsBadRequest());
}
SpecificationSummary specificationSummary = await _specificationService.GetSpecificationSummaryById(specificationId);
List <PublishedProviderVersion> results = new List <PublishedProviderVersion>();
foreach (var fundingStream in specificationSummary.FundingStreams)
{
IEnumerable <PublishedProvider> publishedProviders = await _resiliencePolicy.ExecuteAsync(() =>
_publishedFunding.GetCurrentPublishedProviders(fundingStream.Id, specificationSummary.FundingPeriod.Id));
if (publishedProviders.AnyWithNullCheck())
{
results.AddRange(publishedProviders.Select(_ => _.Current));
}
}
return(new OkObjectResult(results));
}
public void CheckChooseForFundingStatus_GivenSpecificationSummaryNotFound_ThrowsEntityNotFoundException()
{
//Arrange
SpecificationSummary specificationSummary = null;
string errorMessage = $"Failed to find specification with for specification Id '{specificationId}'";
ILogger logger = CreateLogger();
ISpecificationService specificationService = CreateSpecificationService();
specificationService
.GetSpecificationSummaryById(Arg.Is(specificationId))
.Returns(specificationSummary);
SpecificationFundingStatusService specificationFundingStatusService = CreateSpecificationFundingStatusService(logger, specificationService);
//Act
Func <Task> test = async() => await specificationFundingStatusService.CheckChooseForFundingStatus(specificationId);
//Assert
test
.Should()
.ThrowExactly <EntityNotFoundException>()
.Which
.Message
.Should()
.Be(errorMessage);
logger
.Received(1)
.Error(Arg.Is(errorMessage));
}
protected async override Task <IEnumerable <string> > PerformChecks <TSpecification>(TSpecification prereqObject, IEnumerable <PublishedProvider> publishedProviders = null, IEnumerable <Provider> providers = null)
{
Guard.ArgumentNotNull(publishedProviders, nameof(publishedProviders));
SpecificationSummary specification = prereqObject as SpecificationSummary;
Guard.ArgumentNotNull(specification, nameof(specification));
SpecificationFundingStatus specificationFundingStatus = await _specificationFundingStatusService.CheckChooseForFundingStatus(specification);
if (specificationFundingStatus != SpecificationFundingStatus.AlreadyChosen)
{
string errorMessage = $"Specification with id: '{specification.Id}' is not chosen for funding";
_logger.Error(errorMessage);
return(new string[] { errorMessage });
}
List <string> results = new List <string>();
if (publishedProviders?.Any(_ => _.Current.Status == PublishedProviderStatus.Draft || _.Current.Status == PublishedProviderStatus.Updated) ?? false)
{
results.AddRange(publishedProviders.Where(_ => _.Current.Status == PublishedProviderStatus.Draft || _.Current.Status == PublishedProviderStatus.Updated).Select(_ => $"Provider with id:{_.Id} has current status:{_.Current.Status} so cannot be published."));
_logger.Error(string.Join(Environment.NewLine, results));
return(results);
}
return(results);
}
public void ReturnsErrorMessageWhenJobsRunning()
{
// Arrange
string specificationId = "specId01";
SpecificationSummary specificationSummary = new SpecificationSummary {
Id = specificationId
};
string errorMessage = $"{JobConstants.DefinitionNames.CreateInstructAllocationJob} is still running";
GivenTheSpecificationFundingStatusForTheSpecification(specificationSummary, SpecificationFundingStatus.AlreadyChosen);
GivenCalculationEngineRunningStatusForTheSpecification(specificationId, JobConstants.DefinitionNames.CreateInstructAllocationJob);
GivenValidationErrorsForTheSpecification(specificationSummary, Enumerable.Empty <string>());
// Act
Func <Task> invocation
= () => WhenThePreRequisitesAreChecked(specificationSummary, Enumerable.Empty <PublishedProvider>(), Enumerable.Empty <Provider>());
// Assert
invocation
.Should()
.Throw <JobPrereqFailedException>()
.Where(_ =>
_.Message == $"Specification with id: '{specificationSummary.Id} has prerequisites which aren't complete.");
_logger
.Received()
.Error(errorMessage);
}
public async Task <(long saveToCosmosElapsedMs, long saveToSearchElapsedMs)> SaveProviderResults(IEnumerable <ProviderResult> providerResults, int degreeOfParallelism = 5)
{
if (providerResults == null || providerResults.Count() == 0)
{
return(0, 0);
}
IEnumerable <KeyValuePair <string, ProviderResult> > results = providerResults.Select(m => new KeyValuePair <string, ProviderResult>(m.Provider.Id, m));
IEnumerable <string> specificationIds = providerResults.Select(s => s.SpecificationId).Distinct();
Dictionary <string, SpecificationSummary> specifications = new Dictionary <string, SpecificationSummary>();
foreach (string specificationId in specificationIds)
{
SpecificationSummary specification = await _specificationsRepository.GetSpecificationSummaryById(specificationId);
if (specification == null)
{
throw new InvalidOperationException($"Result for Specification Summary lookup was null with ID '{specificationId}'");
}
specifications.Add(specificationId, specification);
}
Task <long> cosmosSaveTask = BulkSaveProviderResults(results, degreeOfParallelism);
Task <long> searchSaveTask = UpdateSearch(providerResults, specifications);
await TaskHelper.WhenAllAndThrow(cosmosSaveTask, searchSaveTask);
return(cosmosSaveTask.Result, searchSaveTask.Result);
}
public async Task Assemble_GivenSpecificationWithTwoFundingStreamsButTemplateContentsNotFoundForOneFundingStream_ReturnsCollectionWithOneItem()
{
//Arrange
TemplateMetadataContents templateMetadataContents = new TemplateMetadataContents();
SpecificationSummary specificationSummary = CreateSpecificationSummary();
IPoliciesApiClient policiesApiClient = CreatePoliciesClient();
policiesApiClient
.GetFundingTemplateContents(Arg.Is("fs-1"), Arg.Is("fp-1"), Arg.Is("1.0"))
.Returns(new ApiResponse <TemplateMetadataContents>(HttpStatusCode.OK, templateMetadataContents));
policiesApiClient
.GetFundingTemplateContents(Arg.Is("fs-2"), Arg.Is("fp-1"), Arg.Is("1.0"))
.Returns((ApiResponse <TemplateMetadataContents>)null);
TemplateMetadataContentsAssemblerService templateMetadataContentsAssemblerService = CreateService(policiesApiClient: policiesApiClient);
//Act
var templateMetadataContentsCollection = await templateMetadataContentsAssemblerService.Assemble(specificationSummary);
//Assert
templateMetadataContentsCollection
.Should()
.HaveCount(1);
templateMetadataContentsCollection
.First().Value
.Should()
.Be(templateMetadataContents);
}
public async Task Assemble_GivenSpecificationWithTwoFundingStreamsAndTemplatesFound_ReturnsCollectionWithTwoItems()
{
//Arrange
TemplateMetadataContents templateMetadataContentsFs1 = new TemplateMetadataContents();
TemplateMetadataContents templateMetadataContentsFs2 = new TemplateMetadataContents();
SpecificationSummary specificationSummary = CreateSpecificationSummary();
IPoliciesApiClient policiesApiClient = CreatePoliciesClient();
policiesApiClient
.GetFundingTemplateContents(Arg.Is("fs-1"), Arg.Is("fp-1"), Arg.Is("1.0"))
.Returns(new ApiResponse <TemplateMetadataContents>(HttpStatusCode.OK, templateMetadataContentsFs1));
policiesApiClient
.GetFundingTemplateContents(Arg.Is("fs-2"), Arg.Is("fp-1"), Arg.Is("1.0"))
.Returns(new ApiResponse <TemplateMetadataContents>(HttpStatusCode.OK, templateMetadataContentsFs2));
TemplateMetadataContentsAssemblerService templateMetadataContentsAssemblerService = CreateService(policiesApiClient: policiesApiClient);
//Act
var templateMetadataContentsCollection = await templateMetadataContentsAssemblerService.Assemble(specificationSummary);
//Assert
templateMetadataContentsCollection
.Should()
.HaveCount(2);
}
private async Task <(bool Complete, IEnumerable <MergeSpecificationRequest> items)> ProduceSpecificationInformation(CancellationToken cancellationToken,
dynamic context)
{
ICosmosDbFeedIterator <ProviderResult> feed = ((MergeContext)context).Feed;
while (feed.HasMoreResults)
{
ProviderResult[] providerResults = (await feed.ReadNext(cancellationToken)).ToArray();
Console.WriteLine($"Processing next {providerResults.Length} provider results");
MergeSpecificationRequest[] requests = providerResults.Select(_ =>
{
SpecificationSummary specificationSummary = GetSpecificationSummary(_.SpecificationId);
Console.WriteLine($"Creating merge specification request for provider {_.Provider.Id} and specification {_.SpecificationId}");
return(new MergeSpecificationRequest(new SpecificationInformation
{
Id = specificationSummary.Id,
Name = specificationSummary.Name,
FundingPeriodId = specificationSummary.FundingPeriod.Id,
LastEditDate = specificationSummary.LastEditedDate
},
_.Provider.Id));
}).ToArray();
return(false, requests);
}
return(true, ArraySegment <MergeSpecificationRequest> .Empty);
}
public async Task <IEnumerable <PublishedProvider> > GetPublishedProvidersForApproval(string specificationId, string[] publishedProviderIds = null)
{
Guard.IsNullOrWhiteSpace(specificationId, nameof(specificationId));
SpecificationSummary specificationSummary = await _specificationsRepositoryPolicy.ExecuteAsync(
() => _specificationService.GetSpecificationSummaryById(specificationId));
ConcurrentBag <PublishedProvider> results = new ConcurrentBag <PublishedProvider>();
string fundingPeriodId = specificationSummary?.FundingPeriod?.Id;
if (fundingPeriodId.IsNullOrWhitespace())
{
string error = "Could not locate a funding period from the supplied funding period id on the specification summary";
throw new InvalidOperationException(error);
}
List <KeyValuePair <string, string> > allPublishedProviderIds = new List <KeyValuePair <string, string> >();
foreach (Common.Models.Reference fundingStream in specificationSummary.FundingStreams)
{
IEnumerable <KeyValuePair <string, string> > publishedProviders = await _publishedFundingRepositoryPolicy.ExecuteAsync(
() => _publishedFundingRepository.GetPublishedProviderIdsForApproval(fundingStream.Id, fundingPeriodId, publishedProviderIds));
allPublishedProviderIds.AddRange(publishedProviders);
}
return(await _publishedFundingBulkRepository.GetPublishedProviders(allPublishedProviderIds));
}
public async Task <IEnumerable <string> > VerifyCalculationPrerequisites(SpecificationSummary specification)
{
List <string> validationErrors = new List <string>();
string specificationId = specification.Id;
ApiResponse <IEnumerable <CalculationMetadata> > calculationsResponse = await _policy.ExecuteAsync(() => _calcsApiClient.GetCalculationMetadataForSpecification(specificationId));
if (calculationsResponse?.Content == null)
{
string errorMessage = $"Did locate any calculation metadata for specification {specificationId}. Unable to complete prerequisite checks";
_logger.Error(errorMessage);
validationErrors.Add(errorMessage);
return(validationErrors);
}
validationErrors.AddRange(calculationsResponse?.Content.Where(_ => _.PublishStatus != PublishStatus.Approved && _.CalculationType == CalculationType.Template)
.Select(_ => $"Calculation {_.Name} must be approved but is {_.PublishStatus}"));
foreach (var fundingStream in specification.FundingStreams)
{
ApiResponse <TemplateMapping> templateMappingResponse = await _calcsApiClient.GetTemplateMapping(specificationId, fundingStream.Id);
foreach (TemplateMappingItem calcInError in templateMappingResponse.Content.TemplateMappingItems.Where(c => string.IsNullOrWhiteSpace(c.CalculationId)))
{
validationErrors.Add($"{calcInError.EntityType} {calcInError.Name} is not mapped to a calculation in CFS");
}
}
return(validationErrors);
}
public void ReturnsErrorMessageWhenCanChooseSpecificationFundingAndErrorSelectingSpecificationForFunding()
{
// Arrange
string specificationId = "specId01";
SpecificationSummary specificationSummary = new SpecificationSummary {
Id = specificationId, ApprovalStatus = PublishStatus.Approved
};
IEnumerable <Provider> providers = new[] { new Provider {
ProviderId = "ProviderId"
} };
string errorMessage = "Generic error message";
GivenTheSpecificationFundingStatusForTheSpecification(specificationSummary, SpecificationFundingStatus.CanChoose);
GivenExceptionThrownForSelectSpecificationForFunding(specificationId, new Exception(errorMessage));
// Act
Func <Task> invocation
= () => WhenThePreRequisitesAreChecked(specificationSummary, Enumerable.Empty <PublishedProvider>(), providers);
// Assert
invocation
.Should()
.Throw <JobPrereqFailedException>()
.Where(_ =>
_.Message == $"Specification with id: '{specificationSummary.Id} has prerequisites which aren't complete.");
_logger
.Received()
.Error(errorMessage);
}
public async Task <IActionResult> OnGetAsync(string specificationId)
{
Guard.IsNullOrWhiteSpace(specificationId, nameof(specificationId));
SpecificationId = specificationId;
SpecificationSummary specification = await GetSpecification(specificationId);
IsAuthorizedToEdit =
await _authorizationHelper.DoesUserHavePermission(User, specification,
SpecificationActionTypes.CanEditSpecification);
if (specification != null)
{
SpecificationName = specification.Name;
FundingPeriodName = specification.FundingPeriod.Name;
FundingPeriodId = specification.FundingPeriod.Id;
return(Page());
}
else
{
throw new InvalidOperationException($"Unable to retreive specification");
}
}
public async Task CheckChooseForFundingStatus_GivenNoSpecSummariesFoundForFundingPeriodId_ReturnsCanChoose()
{
//Arrange
SpecificationSummary specificationSummary = new SpecificationSummary
{
FundingPeriod = new Reference
{
Id = fundingPeriodId
}
};
ISpecificationService specificationService = CreateSpecificationService();
specificationService
.GetSpecificationSummaryById(Arg.Is(specificationId))
.Returns(specificationSummary);
specificationService
.GetSpecificationsSelectedForFundingByPeriod(Arg.Is(fundingPeriodId))
.Returns((IEnumerable <SpecificationSummary>)null);
SpecificationFundingStatusService specificationFundingStatusService = CreateSpecificationFundingStatusService(specificationService: specificationService);
//Act
SpecificationFundingStatus status = await specificationFundingStatusService.CheckChooseForFundingStatus(specificationId);
//Assert
status
.Should()
.Be(SpecificationFundingStatus.CanChoose);
}
public async Task RunTests_GivenNoTestScenarios_LogsAndreturnsEmptyResults()
{
//Arrange
IEnumerable <ProviderResult> providerResults = new[] { new ProviderResult() };
IEnumerable <TestScenario> scenarios = new TestScenario[0];
IEnumerable <ProviderSourceDataset> providerSourceDatasets = new ProviderSourceDataset[0];
IEnumerable <TestScenarioResult> testScenarioResults = new TestScenarioResult[0];
SpecificationSummary specificationSummary = new SpecificationSummary();
BuildProject buildProject = new BuildProject();
ILogger logger = CreateLogger();
TestEngine testEngine = CreateTestEngine(logger: logger);
//Act
IEnumerable <TestScenarioResult> results = await testEngine.RunTests(scenarios, providerResults, providerSourceDatasets,
testScenarioResults, specificationSummary, buildProject);
results
.Count()
.Should()
.Be(0);
logger
.Received(1)
.Warning(Arg.Is("No test scenarios were supplied to execute tests"));
}
public async Task RunTests_GivenNoTestResults_LogsAndreturnsEmptyResults()
{
//Arrange
IEnumerable <ProviderResult> providerResults = new[] { new ProviderResult {
Provider = new ProviderSummary {
Id = ProviderId
}, SpecificationId = SpecificationId
} };
IEnumerable <TestScenario> scenarios = new[] { new TestScenario() };
IEnumerable <ProviderSourceDataset> providerSourceDatasets = new ProviderSourceDataset[0];
IEnumerable <TestScenarioResult> testScenarioResults = new TestScenarioResult[0];
SpecificationSummary specificationSummary = new SpecificationSummary();
BuildProject buildProject = new BuildProject();
ILogger logger = CreateLogger();
TestEngine testEngine = CreateTestEngine(logger: logger);
//Act
IEnumerable <TestScenarioResult> results = await testEngine.RunTests(scenarios, providerResults, providerSourceDatasets,
testScenarioResults, specificationSummary, buildProject);
results
.Count()
.Should()
.Be(0);
logger
.Received(1)
.Warning(Arg.Is($"No test results generated for provider: {ProviderId} on specification: {SpecificationId}"));
}
private async Task <UniqueTemplateContents> GetTemplateData(SpecificationSummary specification, string fundingStreamId)
{
UniqueTemplateContents uniqueTemplateContents = new UniqueTemplateContents();
TemplateMetadataContents templateMetadata = await GetTemplateMetadataContents(specification, fundingStreamId);
if (templateMetadata == null)
{
throw new NonRetriableException(
$"Did not locate template information for specification {specification.Id} in {fundingStreamId}. Unable to complete Qa Schema Generation");
}
IEnumerable <FundingLine> flattenedFundingLines = templateMetadata.RootFundingLines.Flatten(_ => _.FundingLines)
?? new FundingLine[0];
IEnumerable <FundingLine> uniqueFundingLines = flattenedFundingLines.GroupBy(x => x.TemplateLineId)
.Select(f => f.First());
IEnumerable <Calculation> flattenedCalculations =
flattenedFundingLines.SelectMany(_ => _.Calculations.Flatten(cal => cal.Calculations)) ?? new Calculation[0];
IEnumerable <Calculation> uniqueFlattenedCalculations =
flattenedCalculations.GroupBy(x => x.TemplateCalculationId)
.Select(x => x.FirstOrDefault());
uniqueTemplateContents.FundingLines = uniqueFundingLines;
uniqueTemplateContents.Calculations = uniqueFlattenedCalculations;
return(uniqueTemplateContents);
}
public async Task GetFundingConfigurations_GivenSuccessResponse_ReturnsDictionary()
{
//Arrange
SpecificationSummary specificationSummary = CreateSpecificationSummary();
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient();
policiesApiClient
.GetFundingConfiguration(Arg.Any <string>(), Arg.Any <string>())
.Returns(new ApiResponse <FundingConfiguration>(System.Net.HttpStatusCode.OK, new FundingConfiguration()));
FundingConfigurationService fundingConfigurationService = CreateService(policiesApiClient);
//Act
IDictionary <string, FundingConfiguration> results = await fundingConfigurationService.GetFundingConfigurations(specificationSummary);
//Assert
results
.Should()
.HaveCount(3);
results["fs-1"]
.Should()
.NotBeNull();
results["fs-2"]
.Should()
.NotBeNull();
results["fs-3"]
.Should()
.NotBeNull();
}
public async Task <IDictionary <string, TemplateMetadataContents> > Assemble(SpecificationSummary specification)
{
Guard.ArgumentNotNull(specification, nameof(specification));
IDictionary <string, TemplateMetadataContents> templateMetadataContentsCollection = new Dictionary <string, TemplateMetadataContents>();
foreach (Reference fundingStreamReference in specification.FundingStreams)
{
string fundingStreamId = fundingStreamReference.Id;
if (!specification.TemplateIds.ContainsKey(fundingStreamId))
{
string errorMessage = $"Template version for funding stream id '{fundingStreamId}' not found for specification with id '{specification.Id}'";
_logger.Error(errorMessage);
}
else
{
string templateVersion = specification.TemplateIds[fundingStreamId];
ApiResponse <TemplateMetadataContents> templateMetadataContentsResponse = await _policiesApiClient.GetFundingTemplateContents(fundingStreamId, specification.FundingPeriod.Id, templateVersion);
//AB: We will need to revisit this and throw an exception here but while the data is a bit naf
//just want to make sure we can load the page while testing
if (templateMetadataContentsResponse != null && templateMetadataContentsResponse.StatusCode.IsSuccess())
{
templateMetadataContentsCollection.Add(fundingStreamId, templateMetadataContentsResponse.Content);
}
}
}
return(templateMetadataContentsCollection);
}
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 ReturnsErrorMessageWhenCalculationPrequisitesNotMet()
{
// Arrange
string specificationId = "specId01";
SpecificationSummary specificationSummary = new SpecificationSummary {
Id = specificationId, ApprovalStatus = PublishStatus.Approved
};
IEnumerable <Provider> providers = new[] { new Provider {
ProviderId = "ProviderId"
} };
string errorMessage = "Error message";
GivenTheSpecificationFundingStatusForTheSpecification(specificationSummary, SpecificationFundingStatus.AlreadyChosen);
GivenCalculationEngineRunningStatusForTheSpecification(specificationId);
GivenValidationErrorsForTheSpecification(specificationSummary, new List <string> {
errorMessage
});
// Act
Func <Task> invocation
= () => WhenThePreRequisitesAreChecked(specificationSummary, Enumerable.Empty <PublishedProvider>(), providers);
// Assert
invocation
.Should()
.Throw <JobPrereqFailedException>()
.Where(_ =>
_.Message == $"Specification with id: '{specificationSummary.Id} has prerequisites which aren't complete.");
_logger
.Received()
.Error(errorMessage);
}
protected void GivenTheApiResponseDetailsForTheSuppliedId(SpecificationSummary specificationSummary,
HttpStatusCode statusCode = HttpStatusCode.OK)
{
Specifications.GetSpecificationSummaryById(SpecificationId)
.Returns(new ApiResponse <SpecificationSummary>(statusCode,
specificationSummary));
}
public async Task <SpecificationFundingStatus> CheckChooseForFundingStatus(SpecificationSummary specificationSummary)
{
Guard.ArgumentNotNull(specificationSummary, nameof(specificationSummary));
if (specificationSummary.IsSelectedForFunding)
{
return(SpecificationFundingStatus.AlreadyChosen);
}
string fundingPeriodConfigId = specificationSummary.FundingPeriod.Id;
IEnumerable <SpecificationSummary> specificationSummaries = await _specificationService.GetSpecificationsSelectedForFundingByPeriod(fundingPeriodConfigId);
if (specificationSummaries.IsNullOrEmpty())
{
return(SpecificationFundingStatus.CanChoose);
}
HashSet <string> chosenFundingStreams = new HashSet <string>(specificationSummaries.SelectMany(m => m.FundingStreams.Select(fs => fs.Id)));
IEnumerable <string> fundingStreamIds = specificationSummary.FundingStreams.Select(m => m.Id);
if (chosenFundingStreams.Intersect(fundingStreamIds).Any())
{
return(SpecificationFundingStatus.SharesAlreadyChosenFundingStream);
}
else
{
return(SpecificationFundingStatus.CanChoose);
}
}
public async Task GivenTheFollowingSpecificationExists(Table table)
{
SpecificationSummary specificationSummary = table.CreateInstance <SpecificationSummary>();
await _currentSpecificationContext.Repo.AddSpecification(specificationSummary);
_currentSpecificationContext.SpecificationId = specificationSummary.Id;
}
public async Task <PublishedFundingInput> GeneratePublishedFundingInput(IDictionary <string, PublishedProvider> publishedProvidersForFundingStream,
IEnumerable <Provider> scopedProviders,
Reference fundingStream,
SpecificationSummary specification,
IEnumerable <PublishedProvider> publishedProvidersInScope)
{
Guard.ArgumentNotNull(publishedProvidersForFundingStream, nameof(publishedProvidersForFundingStream));
Guard.ArgumentNotNull(scopedProviders, nameof(scopedProviders));
Guard.ArgumentNotNull(fundingStream, nameof(fundingStream));
Guard.ArgumentNotNull(specification, nameof(specification));
_logger.Information($"Fetching existing published funding");
// Get latest version of existing published funding
IEnumerable <PublishedFunding> publishedFunding = await _publishingResiliencePolicy.ExecuteAsync(() =>
_publishedFundingDataService.GetCurrentPublishedFunding(fundingStream.Id, specification.FundingPeriod.Id));
_logger.Information($"Fetched {publishedFunding.Count()} existing published funding items");
_logger.Information($"Generating organisation groups");
FundingConfiguration fundingConfiguration = await _policiesService.GetFundingConfiguration(fundingStream.Id, specification.FundingPeriod.Id);
TemplateMetadataContents templateMetadataContents = await ReadTemplateMetadataContents(fundingStream, specification);
// Foreach group, determine the provider versions required to be latest
IEnumerable <OrganisationGroupResult> organisationGroups =
await _organisationGroupGenerator.GenerateOrganisationGroup(fundingConfiguration, _mapper.Map <IEnumerable <ApiProvider> >(scopedProviders), specification.ProviderVersionId, specification.ProviderSnapshotId);
// filter out organisation groups which don't contain a provider which is in scope
if (!publishedProvidersInScope.IsNullOrEmpty())
{
HashSet <string> publishedProviderIdsInScope = new HashSet <string>(publishedProvidersInScope.DistinctBy(_ => _.Current.ProviderId).Select(_ => _.Current.ProviderId));
organisationGroups = organisationGroups.Where(_ => _.Providers.Any(provider => publishedProviderIdsInScope.Contains(provider.ProviderId)));
}
_logger.Information($"A total of {organisationGroups.Count()} were generated");
_logger.Information($"Generating organisation groups to save");
// Compare existing published provider versions with existing current PublishedFundingVersion
IEnumerable <(PublishedFunding PublishedFunding, OrganisationGroupResult OrganisationGroupResult)> organisationGroupsToSave =
_publishedFundingChangeDetectorService.GenerateOrganisationGroupsToSave(organisationGroups, publishedFunding, publishedProvidersForFundingStream);
_logger.Information($"A total of {organisationGroupsToSave.Count()} organisation groups returned to save");
// Generate PublishedFundingVersion for new and updated PublishedFundings
return(new PublishedFundingInput()
{
OrganisationGroupsToSave = organisationGroupsToSave,
TemplateMetadataContents = templateMetadataContents,
TemplateVersion = specification.TemplateIds[fundingStream.Id],
FundingStream = fundingStream,
FundingPeriod = await _policiesService.GetFundingPeriodByConfigurationId(specification.FundingPeriod.Id),
PublishingDates = await _publishedFundingDateService.GetDatesForSpecification(specification.Id),
SpecificationId = specification.Id,
});
}
private bool HaveDifferentTemplateVersions(SpecificationSummary source, SpecificationSummary destination)
{
/*
* Ensure the template versions of specifications are the same between source and destination
*/
return(!(source.TemplateIds ?? Enumerable.Empty <KeyValuePair <string, string> >())
.SequenceEqual(destination.TemplateIds ?? Enumerable.Empty <KeyValuePair <string, string> >()));
}
private void GivenSpecificationSummary(
HttpStatusCode httpStatusCode,
SpecificationSummary specificationSummary = null)
{
_specificationApiClient
.Setup(_ => _.GetSpecificationSummaryById(
_specificationId))
.ReturnsAsync(new ApiResponse <SpecificationSummary>(httpStatusCode, specificationSummary));
}
public async Task <IActionResult> GetPreviousProfilesForSpecificationForProviderForFundingLine(
string specificationId,
string providerId,
string fundingStreamId,
string fundingLineCode)
{
Guard.ArgumentNotNull(fundingStreamId, nameof(fundingStreamId));
Guard.ArgumentNotNull(specificationId, nameof(specificationId));
Guard.ArgumentNotNull(providerId, nameof(providerId));
Guard.ArgumentNotNull(fundingLineCode, nameof(fundingLineCode));
ApiResponse <IEnumerable <FundingLineChange> > fundingLineApiResponse = await _publishingApiClient
.GetPreviousProfilesForSpecificationForProviderForFundingLine(
specificationId,
providerId,
fundingStreamId,
fundingLineCode);
IActionResult fundingLineErrorResult =
fundingLineApiResponse.IsSuccessOrReturnFailureResult(nameof(PublishedProviderVersion));
if (fundingLineErrorResult != null)
{
return(fundingLineErrorResult);
}
ApiResponse <ProviderVersionSearchResult> providerResponse =
await _providersApiClient.GetCurrentProviderForFundingStream(fundingStreamId, providerId);
IActionResult providerErrorResult =
providerResponse.IsSuccessOrReturnFailureResult(nameof(ProviderVersionSearchResult));
if (providerErrorResult != null)
{
return(providerErrorResult);
}
ApiResponse <SpecificationSummary> specificationResponse = await _specificationsApiClient.GetSpecificationSummaryById(specificationId);
IActionResult specificationErrorResult =
specificationResponse.IsSuccessOrReturnFailureResult(nameof(SpecificationSummary));
if (specificationErrorResult != null)
{
return(specificationErrorResult);
}
SpecificationSummary specification = specificationResponse.Content;
return(Ok(new FundingLineChangesViewModel
{
ProviderName = providerResponse.Content.Name,
SpecificationName = specification.Name,
FundingPeriodName = specification.FundingPeriod.Name,
FundingLineChanges = fundingLineApiResponse.Content
}));
}
