public void ExtractsHeaderValueOffViewModelLastModifiedProperty()
        {
            FundingStructure metadataContents = NewFundingStructure();

            TimedEntityTagHeaderValue headerValue = WhenTheHeaderValueIsExtracted(metadataContents);

            headerValue
            ?.ETag
            ?.Tag
            .Should()
            .Be($"\"{metadataContents.LastModified.ToETagString()}\"");
        }
コード例 #2
0
        public async Task GetFundingStructures_ReturnsFlatStructureWithCorrectLevelsAndInCorrectOrder()
        {
            ValidScenarioSetup(FundingStreamId);

            IActionResult apiResponseResult = await _service.GetFundingStructure(FundingStreamId, FundingPeriodId, SpecificationId);

            List <FundingStructureItem> expectedFundingStructureItems = GetValidMappedFundingStructureItems();

            apiResponseResult.Should().BeOfType <OkObjectResult>();
            OkObjectResult   typedResult           = apiResponseResult as OkObjectResult;
            FundingStructure fundingStructureItems = typedResult?.Value as FundingStructure;

            fundingStructureItems?.Items.Count().Should().Be(4);
            fundingStructureItems?.Items.Should().BeEquivalentTo(expectedFundingStructureItems);
        }
コード例 #3
0
        public async Task <IActionResult> GetFundingStructure(string fundingStreamId, string fundingPeriodId, string specificationId)
        {
            IActionResult specificationSummaryResult = await _specificationsService.GetSpecificationSummaryById(specificationId);

            if (!(specificationSummaryResult is OkObjectResult))
            {
                return(specificationSummaryResult);
            }

            SpecificationSummary specificationSummary = (specificationSummaryResult as OkObjectResult).Value
                                                        as SpecificationSummary;

            string templateVersion = specificationSummary.TemplateIds.ContainsKey(fundingStreamId)
                ? specificationSummary.TemplateIds[fundingStreamId]
                : null;

            if (templateVersion == null)
            {
                return(new InternalServerErrorResult(
                           $"Specification contains no matching template version for funding stream '{fundingStreamId}'"));
            }

            ApiResponse <TemplateMetadataContents> templateMetadataContentsApiResponse =
                await _policiesResilience.ExecuteAsync(() => _policiesApiClient.GetFundingTemplateContents(fundingStreamId, fundingPeriodId, templateVersion));

            IActionResult templateMetadataContentsApiResponseErrorResult =
                templateMetadataContentsApiResponse.IsSuccessOrReturnFailureResult("GetFundingTemplateContents");

            if (templateMetadataContentsApiResponseErrorResult != null)
            {
                return(templateMetadataContentsApiResponseErrorResult);
            }

            ApiResponse <TemplateMapping> templateMappingResponse =
                await _calculationsResilience.ExecuteAsync(() => _calculationsApiClient.GetTemplateMapping(specificationId, fundingStreamId));

            IActionResult templateMappingResponseErrorResult =
                templateMappingResponse.IsSuccessOrReturnFailureResult("GetTemplateMapping");

            if (templateMappingResponseErrorResult != null)
            {
                return(templateMappingResponseErrorResult);
            }

            ApiResponse <IEnumerable <CalculationMetadata> > calculationMetadata =
                await _calculationsResilience.ExecuteAsync(() => _calculationsApiClient.GetCalculationMetadataForSpecification(specificationId));

            IActionResult calculationMetadataErrorResult =
                calculationMetadata.IsSuccessOrReturnFailureResult("calculationMetadata");

            if (calculationMetadataErrorResult != null)
            {
                return(calculationMetadataErrorResult);
            }

            List <string> calculationIdsWithError = new List <string>();

            ApiResponse <IEnumerable <Entity <Calculation> > > getCircularDependenciesApiResponse =
                await _graphApiClient.GetCircularDependencies(specificationId);

            IActionResult circularDependenciesApiErrorResult =
                getCircularDependenciesApiResponse.IsSuccessOrReturnFailureResult("GetCircularDependencies");

            if (circularDependenciesApiErrorResult == null)
            {
                calculationIdsWithError =
                    getCircularDependenciesApiResponse.Content.Select(calcs => calcs.Node.CalculationId).ToList();
            }

            List <FundingStructureItem> fundingStructures = new List <FundingStructureItem>();

            RecursivelyAddFundingLineToFundingStructure(
                fundingStructures,
                templateMetadataContentsApiResponse.Content.RootFundingLines,
                templateMappingResponse.Content.TemplateMappingItems.ToList(),
                calculationMetadata.Content.ToList(),
                calculationIdsWithError);

            FundingStructure fundingStructure = new FundingStructure
            {
                Items        = fundingStructures,
                LastModified = await GetFundingStructureTimeStamp(fundingStreamId,
                                                                  fundingPeriodId,
                                                                  specificationId)
            };

            return(new OkObjectResult(fundingStructure));
        }