Ejemplo n.º 1
0
        private static ProviderVariation CreateProviderVariationFromAllocationNotificationFeedIndexItem(
            AllocationNotificationFeedIndex firstEntry)
        {
            ProviderVariation providerVariation = new ProviderVariation();

            if (!firstEntry.VariationReasons.IsNullOrEmpty())
            {
                providerVariation.VariationReasons = new Collection <string>(firstEntry.VariationReasons);
            }

            if (!firstEntry.Successors.IsNullOrEmpty())
            {
                List <ProviderInformationModel> providerInformationModels =
                    firstEntry.Successors.Select(fi => new ProviderInformationModel()
                {
                    Ukprn = fi
                }).ToList();
                providerVariation.Successors = new Collection <ProviderInformationModel>(providerInformationModels);
            }

            if (!firstEntry.Predecessors.IsNullOrEmpty())
            {
                List <ProviderInformationModel> providerInformationModels =
                    firstEntry.Predecessors.Select(fi => new ProviderInformationModel()
                {
                    Ukprn = fi
                }).ToList();
                providerVariation.Predecessors = new Collection <ProviderInformationModel>(providerInformationModels);
            }

            providerVariation.OpenReason  = firstEntry.OpenReason;
            providerVariation.CloseReason = firstEntry.CloseReason;
            return(providerVariation);
        }
Ejemplo n.º 2
0
        private static void AssertProviderVariationValuesNotSet(ProviderVariation providerVariation)
        {
            providerVariation.Should().NotBeNull();

            providerVariation.CloseReason.Should().BeNull();
            providerVariation.OpenReason.Should().BeNull();
            providerVariation.Predecessors.Should().BeNull();
            providerVariation.Successors.Should().BeNull();
            providerVariation.VariationReasons.Should().BeNull();
        }
Ejemplo n.º 3
0
        AllocationModel CreateAllocation(PublishedProviderResult publishedProviderResult)
        {
            ProviderVariation providerVariation = new ProviderVariation();

            PublishedAllocationLineResult allocationLineResult = publishedProviderResult.FundingStreamResult.AllocationLineResult;

            if (!allocationLineResult.Current.VariationReasons.IsNullOrEmpty())
            {
                providerVariation.VariationReasons = new Collection <string>(allocationLineResult.Current.VariationReasons.Select(vr => vr.ToString()).ToList());
            }

            if (allocationLineResult.Current.Provider.Successor != null)
            {
                providerVariation.Successors = new Collection <ProviderInformationModel> {
                    new ProviderInformationModel()
                    {
                        Ukprn = allocationLineResult.Current.Provider.Successor
                    }
                };
            }

            if (!allocationLineResult.Current.Predecessors.IsNullOrEmpty())
            {
                List <ProviderInformationModel> providerModelsForPredecessor = allocationLineResult.Current.Predecessors.Select(fi => new ProviderInformationModel()
                {
                    Ukprn = fi
                }).ToList();
                providerVariation.Predecessors = new Collection <ProviderInformationModel>(providerModelsForPredecessor);
            }

            providerVariation.OpenReason  = allocationLineResult.Current.Provider.ReasonEstablishmentOpened;
            providerVariation.CloseReason = allocationLineResult.Current.Provider.ReasonEstablishmentClosed;

            return(new AllocationModel
            {
                AllocationResultTitle = $"Allocation {publishedProviderResult.FundingStreamResult.AllocationLineResult.AllocationLine.Name} was {publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Status}",
                AllocationResultId = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.FeedIndexId,
                AllocationAmount = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Value.HasValue
                    ? publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Value.Value
                    : 0,
                AllocationMajorVersion = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Major,
                AllocationMinorVersion = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Minor,
                AllocationLine = new AllocationLine
                {
                    Id = publishedProviderResult.FundingStreamResult.AllocationLineResult.AllocationLine.Id,
                    Name = publishedProviderResult.FundingStreamResult.AllocationLineResult.AllocationLine.Name,
                    ShortName = publishedProviderResult.FundingStreamResult.AllocationLineResult.AllocationLine.ShortName,
                    FundingRoute = publishedProviderResult.FundingStreamResult.AllocationLineResult.AllocationLine.FundingRoute.ToString(),
                    ContractRequired = publishedProviderResult.FundingStreamResult.AllocationLineResult.AllocationLine.IsContractRequired
                        ? "Y"
                        : "N"
                },
                AllocationStatus = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Status.ToString(),
                FundingStream = new AllocationFundingStreamModel
                {
                    Id = publishedProviderResult.FundingStreamResult.FundingStream.Id,
                    Name = publishedProviderResult.FundingStreamResult.FundingStream.Name,
                    ShortName = publishedProviderResult.FundingStreamResult.FundingStream.ShortName,
                    PeriodType = new AllocationFundingStreamPeriodTypeModel
                    {
                        Id = publishedProviderResult.FundingStreamResult.FundingStream.PeriodType.Id,
                        Name = publishedProviderResult.FundingStreamResult.FundingStream.PeriodType.Id,
                        StartDay = publishedProviderResult.FundingStreamResult.FundingStream.PeriodType.StartDay,
                        StartMonth = publishedProviderResult.FundingStreamResult.FundingStream.PeriodType.StartMonth,
                        EndDay = publishedProviderResult.FundingStreamResult.FundingStream.PeriodType.EndDay,
                        EndMonth = publishedProviderResult.FundingStreamResult.FundingStream.PeriodType.EndMonth,
                    }
                },
                Period = new Period
                {
                    Id = publishedProviderResult.FundingPeriod.Id,
                    Name = publishedProviderResult.FundingPeriod.Name,
                    StartYear = publishedProviderResult.FundingPeriod.StartYear,
                    EndYear = publishedProviderResult.FundingPeriod.EndYear
                },
                Provider = new AllocationProviderModel
                {
                    Name = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.Name,
                    LegalName = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.LegalName,
                    UkPrn = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.UKPRN,
                    Upin = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.UPIN,
                    Urn = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.URN,
                    DfeEstablishmentNumber = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.DfeEstablishmentNumber,
                    EstablishmentNumber = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.EstablishmentNumber,
                    LaCode = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.LACode,
                    LocalAuthority = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.Authority,
                    Type = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.ProviderType,
                    SubType = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.ProviderSubType,
                    OpenDate = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.DateOpened,
                    CloseDate = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.DateClosed,
                    CrmAccountId = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.CrmAccountId,
                    NavVendorNo = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.NavVendorNo,
                    Status = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.Status,
                    ProviderId = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.Id,
                    ProviderVariation = providerVariation
                },
                ProfilePeriods = publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.ProfilingPeriods != null
                    ? new List <ProfilePeriod>(publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.ProfilingPeriods
                                               .Select(m => new ProfilePeriod
                {
                    DistributionPeriod = m.DistributionPeriod,
                    Occurrence = m.Occurrence,
                    Period = m.Period,
                    PeriodType = m.Type,
                    PeriodYear = m.Year.ToString(),
                    ProfileValue = m.Value
                })
                                               .ToArraySafe())
                    : new List <ProfilePeriod>(),
            });
        }
Ejemplo n.º 4
0
        private ProviderResultSummary CreateProviderResultSummary(IEnumerable <AllocationNotificationFeedIndex> entries, HttpRequest request)
        {
            IEnumerable <IGrouping <string, AllocationNotificationFeedIndex> > fundingPeriodResultSummaryGroups = entries.GroupBy(m => m.FundingPeriodId);

            AllocationNotificationFeedIndex firstEntry = entries.First();

            ProviderVariation providerVariation = CreateProviderVariationFromAllocationNotificationFeedIndexItem(firstEntry);

            ProviderResultSummary providerResutSummary = new ProviderResultSummary
            {
                Provider = new AllocationProviderModel
                {
                    Name      = firstEntry.ProviderName,
                    LegalName = firstEntry.ProviderLegalName,
                    UkPrn     = firstEntry.ProviderUkPrn,
                    Upin      = firstEntry.ProviderUpin,
                    Urn       = firstEntry.ProviderUrn,
                    DfeEstablishmentNumber = firstEntry.DfeEstablishmentNumber,
                    EstablishmentNumber    = firstEntry.EstablishmentNumber,
                    LaCode            = firstEntry.LaCode,
                    LocalAuthority    = firstEntry.Authority,
                    Type              = firstEntry.ProviderType,
                    SubType           = firstEntry.SubProviderType,
                    OpenDate          = firstEntry.ProviderOpenDate,
                    CloseDate         = firstEntry.ProviderClosedDate,
                    CrmAccountId      = firstEntry.CrmAccountId,
                    NavVendorNo       = firstEntry.NavVendorNo,
                    Status            = firstEntry.ProviderStatus,
                    ProviderVariation = providerVariation
                }
            };

            foreach (IGrouping <string, AllocationNotificationFeedIndex> fundingPeriodResultSummaryGroup in fundingPeriodResultSummaryGroups)
            {
                AllocationNotificationFeedIndex firstPeriodEntry = fundingPeriodResultSummaryGroup.First();

                ProviderPeriodResultSummary providerPeriodResultSummary = new ProviderPeriodResultSummary
                {
                    Period = new Period
                    {
                        Id        = firstPeriodEntry.FundingPeriodId,
                        Name      = firstPeriodEntry.FundingStreamPeriodName,
                        StartYear = firstPeriodEntry.FundingPeriodStartYear,
                        EndYear   = firstPeriodEntry.FundingPeriodEndYear
                    }
                };

                IEnumerable <IGrouping <string, AllocationNotificationFeedIndex> > fundingStreamResultSummaryGroups = fundingPeriodResultSummaryGroup.GroupBy(m => m.FundingStreamId);

                foreach (IGrouping <string, AllocationNotificationFeedIndex> fundingStreamResultSummaryGroup in fundingStreamResultSummaryGroups)
                {
                    AllocationNotificationFeedIndex feedIndex = fundingStreamResultSummaryGroup.First();

                    FundingStreamResultSummary fundingStreamResultSummary = new FundingStreamResultSummary
                    {
                        FundingStream = new AllocationFundingStreamModel
                        {
                            Id         = feedIndex.FundingStreamId,
                            Name       = feedIndex.FundingStreamName,
                            ShortName  = feedIndex.FundingStreamShortName,
                            PeriodType = new AllocationFundingStreamPeriodTypeModel
                            {
                                Id         = feedIndex.FundingStreamPeriodId,
                                Name       = feedIndex.FundingStreamPeriodName,
                                StartDay   = feedIndex.FundingStreamStartDay,
                                StartMonth = feedIndex.FundingStreamStartMonth,
                                EndDay     = feedIndex.FundingStreamEndDay,
                                EndMonth   = feedIndex.FundingStreamEndMonth
                            },
                            //todo Version = feedIndex.FundingStreamVersionNumber
                            //todo Version = feedIndex.FundingStreamVersion
                        }
                    };

                    foreach (AllocationNotificationFeedIndex allocationFeedIndex in fundingStreamResultSummaryGroup)
                    {
                        IEnumerable <PublishedProviderResultsPolicySummary> policySummaries = JsonConvert.DeserializeObject <IEnumerable <PublishedProviderResultsPolicySummary> >(feedIndex.PolicySummaries);
                        IList <CalculationResult> calculations = new List <CalculationResult>();

                        if (!string.IsNullOrWhiteSpace(feedIndex.PolicySummaries))
                        {
                            foreach (PublishedProviderResultsPolicySummary publishedPolicySummaryResult in policySummaries)
                            {
                                foreach (PublishedProviderResultsCalculationSummary publishedCalculationSummary in publishedPolicySummaryResult.Calculations)
                                {
                                    calculations.Add(new Models.CalculationResult
                                    {
                                        CalculationName          = publishedCalculationSummary.Name,
                                        CalculationVersionNumber = (ushort)publishedCalculationSummary.Version,
                                        CalculationType          = publishedCalculationSummary.CalculationType.ToString(),
                                        CalculationValue         = publishedCalculationSummary.Amount,
                                        PolicyId = publishedPolicySummaryResult.Policy.Id,

                                        //todo CalculationDisplayName = publishedCalculationSummary.DisplayName,
                                        //todo AssociatedWithAllocation = publishedCalculationSummary.AssociatedWithAllocation ? true
                                    });
                                }
                            }
                        }

                        fundingStreamResultSummary.Allocations.Add(new AllocationResult
                        {
                            AllocationLine = new AllocationLine
                            {
                                Id               = allocationFeedIndex.AllocationLineId,
                                Name             = allocationFeedIndex.AllocationLineName,
                                ShortName        = allocationFeedIndex.AllocationLineShortName,
                                FundingRoute     = allocationFeedIndex.AllocationLineFundingRoute,
                                ContractRequired = allocationFeedIndex.AllocationLineContractRequired ? "Y" : "N"
                            },
                            AllocationMajorVersion = feedIndex.MajorVersion ?? 0,
                            AllocationMinorVersion = feedIndex.MinorVersion ?? 0,
                            AllocationStatus       = allocationFeedIndex.AllocationStatus,
                            AllocationAmount       = Convert.ToDecimal(allocationFeedIndex.AllocationAmount),
                            ProfilePeriods         = new Collection <ProfilePeriod>(JsonConvert.DeserializeObject <IEnumerable <ProfilingPeriod> >(allocationFeedIndex.ProviderProfiling)
                                                                                    .Select(m => new ProfilePeriod(m.Period, m.Occurrence, m.Year.ToString(), m.Type, m.Value, m.DistributionPeriod))
                                                                                    .ToArraySafe()),
                            Calculations = new Collection <CalculationResult>(calculations)
                        });
                    }

                    fundingStreamResultSummary.FundingStreamTotalAmount = fundingStreamResultSummary.Allocations.Sum(m => m.AllocationAmount);

                    providerResutSummary.FundingStreamTotalAmount += fundingStreamResultSummary.FundingStreamTotalAmount;

                    providerPeriodResultSummary.FundingStreamResults.Add(fundingStreamResultSummary);
                }

                providerResutSummary.FundingPeriodResults = new Collection <ProviderPeriodResultSummary>(
                    providerResutSummary.FundingPeriodResults.Concat(new[] { providerPeriodResultSummary }).ToArraySafe());
            }

            return(providerResutSummary);
        }
Ejemplo n.º 5
0
        private LocalAuthorityResultsSummary CreateLocalAuthorityResultsSummary(IEnumerable <AllocationNotificationFeedIndex> entries, HttpRequest request)
        {
            IEnumerable <IGrouping <string, AllocationNotificationFeedIndex> > localAuthorityResultSummaryGroups = entries.GroupBy(m => m.LaCode);

            AllocationNotificationFeedIndex firstEntry = entries.First();

            LocalAuthorityResultsSummary localAuthorityResultsSummary = new LocalAuthorityResultsSummary
            {
                FundingPeriod = $"{firstEntry.FundingPeriodStartYear}-{firstEntry.FundingPeriodEndYear}"
            };

            foreach (IGrouping <string, AllocationNotificationFeedIndex> localAuthorityResultSummaryGroup in localAuthorityResultSummaryGroups.ToList())
            {
                AllocationNotificationFeedIndex firstFeedIndex = localAuthorityResultSummaryGroup.First();

                LocalAuthorityResultSummary localAuthorityResultSummary = new LocalAuthorityResultSummary
                {
                    LANo   = firstFeedIndex.LaCode,
                    LAName = firstFeedIndex.Authority
                };

                foreach (AllocationNotificationFeedIndex feedIndex in localAuthorityResultSummaryGroup)
                {
                    ProviderVariation providerVariation = CreateProviderVariationFromAllocationNotificationFeedIndexItem(feedIndex);
                    LocalAuthorityProviderResultSummary resultSummary = new LocalAuthorityProviderResultSummary
                    {
                        Provider = new AllocationProviderModel
                        {
                            ProviderId             = feedIndex.ProviderId,
                            Name                   = feedIndex.ProviderName,
                            LegalName              = feedIndex.ProviderLegalName,
                            UkPrn                  = feedIndex.ProviderUkPrn,
                            Upin                   = feedIndex.ProviderUpin,
                            Urn                    = feedIndex.ProviderUrn,
                            DfeEstablishmentNumber = feedIndex.DfeEstablishmentNumber,
                            EstablishmentNumber    = feedIndex.EstablishmentNumber,
                            LaCode                 = feedIndex.LaCode,
                            LocalAuthority         = feedIndex.Authority,
                            Type                   = feedIndex.ProviderType,
                            SubType                = feedIndex.SubProviderType,
                            OpenDate               = feedIndex.ProviderOpenDate,
                            CloseDate              = feedIndex.ProviderClosedDate,
                            CrmAccountId           = feedIndex.CrmAccountId,
                            NavVendorNo            = feedIndex.NavVendorNo,
                            Status                 = feedIndex.ProviderStatus,
                            ProviderVariation      = providerVariation
                        }
                    };

                    IEnumerable <IGrouping <string, AllocationNotificationFeedIndex> > fundingPeriodResultSummaryGroups = localAuthorityResultSummaryGroup.GroupBy(m => m.FundingPeriodId);

                    foreach (IGrouping <string, AllocationNotificationFeedIndex> fundingPeriodResultSummaryGroup in fundingPeriodResultSummaryGroups)
                    {
                        AllocationNotificationFeedIndex fundingPeriodFeedIndex = fundingPeriodResultSummaryGroup.First();

                        FundingPeriodResultSummary fundingPeriodResultSummary = new FundingPeriodResultSummary
                        {
                            Period = new Period
                            {
                                Id        = fundingPeriodFeedIndex.FundingPeriodId,
                                Name      = fundingPeriodFeedIndex.FundingStreamPeriodName,
                                StartYear = fundingPeriodFeedIndex.FundingPeriodStartYear,
                                EndYear   = fundingPeriodFeedIndex.FundingPeriodEndYear
                            },
                            FundingStream = new AllocationFundingStreamModel
                            {
                                Id         = feedIndex.FundingStreamId,
                                Name       = feedIndex.FundingStreamName,
                                ShortName  = feedIndex.FundingStreamShortName,
                                PeriodType = new AllocationFundingStreamPeriodTypeModel
                                {
                                    Id         = feedIndex.FundingStreamPeriodId,
                                    Name       = feedIndex.FundingStreamPeriodName,
                                    StartDay   = feedIndex.FundingStreamStartDay,
                                    StartMonth = feedIndex.FundingStreamStartMonth,
                                    EndDay     = feedIndex.FundingStreamEndDay,
                                    EndMonth   = feedIndex.FundingStreamEndMonth
                                }
                            }
                        };

                        foreach (AllocationNotificationFeedIndex allocationFeedIndex in fundingPeriodResultSummaryGroup)
                        {
                            if (allocationFeedIndex.ProviderId != resultSummary.Provider.ProviderId)
                            {
                                continue;
                            }

                            AllocationResultWIthProfilePeriod allocationResultWIthProfilePeriod = new AllocationResultWIthProfilePeriod
                            {
                                AllocationLine = new AllocationLine
                                {
                                    Id               = allocationFeedIndex.AllocationLineId,
                                    Name             = allocationFeedIndex.AllocationLineName,
                                    ShortName        = allocationFeedIndex.AllocationLineShortName,
                                    FundingRoute     = allocationFeedIndex.AllocationLineFundingRoute,
                                    ContractRequired = allocationFeedIndex.AllocationLineContractRequired ? "Y" : "N"
                                },
                                AllocationStatus       = allocationFeedIndex.AllocationStatus,
                                AllocationMajorVersion = feedIndex.MajorVersion ?? 0,
                                AllocationMinorVersion = feedIndex.MinorVersion ?? 0,
                                AllocationAmount       = Convert.ToDecimal(allocationFeedIndex.AllocationAmount)
                            };

                            resultSummary.AllocationValue += allocationResultWIthProfilePeriod.AllocationAmount;

                            ProfilingPeriod[] profilingPeriods = JsonConvert.DeserializeObject <ProfilingPeriod[]>(allocationFeedIndex.ProviderProfiling);

                            foreach (ProfilingPeriod profilingPeriod in profilingPeriods)
                            {
                                allocationResultWIthProfilePeriod.ProfilePeriods = new Collection <ProfilePeriod>(allocationResultWIthProfilePeriod.ProfilePeriods.Concat(new[]
                                {
                                    new ProfilePeriod
                                    {
                                        Period             = profilingPeriod.Period,
                                        Occurrence         = profilingPeriod.Occurrence,
                                        PeriodYear         = profilingPeriod.Year.ToString(),
                                        PeriodType         = profilingPeriod.Type,
                                        ProfileValue       = profilingPeriod.Value,
                                        DistributionPeriod = profilingPeriod.DistributionPeriod
                                    }
                                }).ToArraySafe());
                            }

                            fundingPeriodResultSummary.Allocations = new Collection <AllocationResultWIthProfilePeriod>(fundingPeriodResultSummary.Allocations.Concat(new[]
                            {
                                allocationResultWIthProfilePeriod
                            }).ToArraySafe());
                        }

                        resultSummary.FundingPeriods = new Collection <FundingPeriodResultSummary>(resultSummary.FundingPeriods.Concat(new[]
                        {
                            fundingPeriodResultSummary
                        }).ToArraySafe());
                    }

                    localAuthorityResultSummary.Providers = new Collection <LocalAuthorityProviderResultSummary>(localAuthorityResultSummary.Providers.Concat(new[] { resultSummary }).ToArraySafe());
                }

                localAuthorityResultSummary.TotalAllocation = localAuthorityResultSummary.Providers.Sum(m => m.AllocationValue);

                localAuthorityResultsSummary.LocalAuthorities = new Collection <LocalAuthorityResultSummary>(localAuthorityResultsSummary.LocalAuthorities.Concat(new[] { localAuthorityResultSummary }).ToArraySafe());
            }

            localAuthorityResultsSummary.TotalAllocation = localAuthorityResultsSummary.LocalAuthorities.Sum(m => m.TotalAllocation);

            return(localAuthorityResultsSummary);
        }
        private AtomFeed <AllocationModel> CreateAtomFeed(SearchFeedV2 <AllocationNotificationFeedIndex> searchFeed, HttpRequest request)
        {
            const string notificationsEndpointName    = "notifications";
            string       baseRequestPath              = request.Path.Value.Substring(0, request.Path.Value.IndexOf(notificationsEndpointName, StringComparison.Ordinal) + notificationsEndpointName.Length);
            string       allocationTrimmedRequestPath = baseRequestPath.Replace(notificationsEndpointName, string.Empty).TrimEnd('/');

            string queryString = request.QueryString.Value;

            string notificationsUrl = $"{request.Scheme}://{request.Host.Value}{baseRequestPath}{{0}}{(!string.IsNullOrWhiteSpace(queryString) ? queryString : "")}";

            AtomFeed <AllocationModel> atomFeed = new AtomFeed <AllocationModel>
            {
                Id     = Guid.NewGuid().ToString("N"),
                Title  = "Calculate Funding Service Allocation Feed",
                Author = new AtomAuthor
                {
                    Name  = "Calculate Funding Service",
                    Email = "*****@*****.**"
                },
                Updated    = DateTimeOffset.Now,
                Rights     = "Copyright (C) 2019 Department for Education",
                Link       = searchFeed.GenerateAtomLinksForResultGivenBaseUrl(notificationsUrl).ToList(),
                AtomEntry  = new List <AtomEntry <AllocationModel> >(),
                IsArchived = searchFeed.IsArchivePage
            };

            foreach (AllocationNotificationFeedIndex feedIndex in searchFeed.Entries)
            {
                ProviderVariation providerVariation = new ProviderVariation();

                if (!feedIndex.VariationReasons.IsNullOrEmpty())
                {
                    providerVariation.VariationReasons = new Collection <string>(feedIndex.VariationReasons);
                }

                if (!feedIndex.Successors.IsNullOrEmpty())
                {
                    List <ProviderInformationModel> providerInformationModels = feedIndex.Successors.Select(fi => new ProviderInformationModel()
                    {
                        Ukprn = fi
                    }).ToList();
                    providerVariation.Successors = new Collection <ProviderInformationModel>(providerInformationModels);
                }

                if (!feedIndex.Predecessors.IsNullOrEmpty())
                {
                    List <ProviderInformationModel> providerInformationModels = feedIndex.Predecessors.Select(fi => new ProviderInformationModel()
                    {
                        Ukprn = fi
                    }).ToList();
                    providerVariation.Predecessors = new Collection <ProviderInformationModel>(providerInformationModels);
                }

                providerVariation.OpenReason  = feedIndex.OpenReason;
                providerVariation.CloseReason = feedIndex.CloseReason;

                atomFeed.AtomEntry.Add(new AtomEntry <AllocationModel>
                {
                    Id        = $"{request.Scheme}://{request.Host.Value}{allocationTrimmedRequestPath}/{feedIndex.Id}",
                    Title     = feedIndex.Title,
                    Summary   = feedIndex.Summary,
                    Published = feedIndex.DatePublished,
                    Updated   = feedIndex.DateUpdated.Value,
                    Version   = $"{feedIndex.MajorVersion}.{feedIndex.MinorVersion}",
                    Link      = new AtomLink("Allocation", $"{ request.Scheme }://{request.Host.Value}{allocationTrimmedRequestPath}/{feedIndex.Id}"),
                    Content   = new AtomContent <AllocationModel>
                    {
                        Allocation = new AllocationModel
                        {
                            FundingStream = new AllocationFundingStreamModel
                            {
                                Id         = feedIndex.FundingStreamId,
                                Name       = feedIndex.FundingStreamName,
                                ShortName  = feedIndex.FundingStreamShortName,
                                PeriodType = new AllocationFundingStreamPeriodTypeModel
                                {
                                    Id         = feedIndex.FundingStreamPeriodId,
                                    Name       = feedIndex.FundingStreamPeriodName,
                                    StartDay   = feedIndex.FundingStreamStartDay,
                                    StartMonth = feedIndex.FundingStreamStartMonth,
                                    EndDay     = feedIndex.FundingStreamEndDay,
                                    EndMonth   = feedIndex.FundingStreamEndMonth
                                }
                            },
                            Period = new Period
                            {
                                Id        = feedIndex.FundingPeriodId,
                                Name      = feedIndex.FundingStreamPeriodName,
                                StartYear = feedIndex.FundingPeriodStartYear,
                                EndYear   = feedIndex.FundingPeriodEndYear
                            },
                            Provider = new AllocationProviderModel
                            {
                                Name      = feedIndex.ProviderName,
                                LegalName = feedIndex.ProviderLegalName,
                                UkPrn     = feedIndex.ProviderUkPrn,
                                Upin      = feedIndex.ProviderUpin,
                                Urn       = feedIndex.ProviderUrn,
                                DfeEstablishmentNumber = feedIndex.DfeEstablishmentNumber,
                                EstablishmentNumber    = feedIndex.EstablishmentNumber,
                                LaCode            = feedIndex.LaCode,
                                LocalAuthority    = feedIndex.Authority,
                                Type              = feedIndex.ProviderType,
                                SubType           = feedIndex.SubProviderType,
                                OpenDate          = feedIndex.ProviderOpenDate,
                                CloseDate         = feedIndex.ProviderClosedDate,
                                CrmAccountId      = feedIndex.CrmAccountId,
                                NavVendorNo       = feedIndex.NavVendorNo,
                                Status            = feedIndex.ProviderStatus,
                                ProviderId        = feedIndex.ProviderId,
                                ProviderVariation = providerVariation
                            },
                            AllocationLine = new AllocationLine
                            {
                                Id               = feedIndex.AllocationLineId,
                                Name             = feedIndex.AllocationLineName,
                                ShortName        = feedIndex.AllocationLineShortName,
                                FundingRoute     = feedIndex.AllocationLineFundingRoute,
                                ContractRequired = feedIndex.AllocationLineContractRequired ? "Y" : "N"
                            },
                            AllocationMajorVersion = feedIndex.MajorVersion ?? 0,
                            AllocationMinorVersion = feedIndex.MinorVersion ?? 0,
                            AllocationStatus       = feedIndex.AllocationStatus,
                            AllocationAmount       = (decimal)feedIndex.AllocationAmount,
                            AllocationResultId     = feedIndex.Id,
                            AllocationResultTitle  = feedIndex.Title,
                            ProfilePeriods         = string.IsNullOrEmpty(feedIndex.ProviderProfiling)
                                ? new List <ProfilePeriod>()
                                : new List <ProfilePeriod>(JsonConvert
                                                           .DeserializeObject <IEnumerable <ProfilingPeriod> >(feedIndex.ProviderProfiling)
                                                           .Select(m => new ProfilePeriod(m.Period, m.Occurrence, m.Year.ToString(), m.Type, m.Value, m.DistributionPeriod))
                                                           .ToArraySafe())
                        }
                    }
                });
            }

            return(atomFeed);
        }
Ejemplo n.º 7
0
        public void GetAllocationByAllocationResultId_GivenResultHasVariation_ReturnsContentResult()
        {
            //Arrange
            string allocationResultId = "12345";

            IHeaderDictionary headerDictionary = new HeaderDictionary();

            headerDictionary.Add("Accept", new StringValues("application/json"));

            HttpRequest request = Substitute.For <HttpRequest>();

            request
            .Headers
            .Returns(headerDictionary);

            PublishedProviderResult publishedProviderResult = CreatePublishedProviderResult();

            publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.FeedIndexId        = allocationResultId;
            publishedProviderResult.FundingStreamResult.AllocationLineResult.HasResultBeenVaried        = true;
            publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.VariationReasons   = new[] { VariationReason.LegalNameFieldUpdated, VariationReason.LACodeFieldUpdated };
            publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.Successor = "provider3";
            publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Predecessors       = new[] { "provider1", "provider2" };
            publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.ReasonEstablishmentOpened = "Fresh Start";
            publishedProviderResult.FundingStreamResult.AllocationLineResult.Current.Provider.ReasonEstablishmentClosed = "Closure";


            IPublishedResultsService resultsService = CreateResultsService();

            resultsService
            .GetPublishedProviderResultByVersionId(Arg.Is(allocationResultId))
            .Returns(publishedProviderResult);

            AllocationsService service = CreateService(resultsService);

            //Act
            IActionResult result = service.GetAllocationByAllocationResultId(allocationResultId, request);

            //Assert
            result
            .Should()
            .BeOfType <ContentResult>();

            ContentResult contentResult = result as ContentResult;

            AllocationModel allocationModel = JsonConvert.DeserializeObject <AllocationModel>(contentResult.Content);

            allocationModel
            .Should()
            .NotBeNull();

            allocationModel.AllocationResultId.Should().Be(allocationResultId);
            allocationModel.AllocationStatus.Should().Be("Published");
            allocationModel.AllocationAmount.Should().Be(50);
            allocationModel.FundingStream.Id.Should().Be("fs-1");
            allocationModel.FundingStream.Name.Should().Be("funding stream 1");
            allocationModel.Period.Id.Should().Be("Ay12345");
            allocationModel.Provider.UkPrn.Should().Be("1111");
            allocationModel.Provider.Upin.Should().Be("2222");
            allocationModel.Provider.OpenDate.Should().NotBeNull();
            allocationModel.AllocationLine.Id.Should().Be("AAAAA");
            allocationModel.AllocationLine.Name.Should().Be("test allocation line 1");
            allocationModel.ProfilePeriods.Should().HaveCount(1);

            ProviderVariation providerVariationModel = allocationModel.Provider.ProviderVariation;

            providerVariationModel.Should().NotBeNull();
            providerVariationModel.VariationReasons.Should().BeEquivalentTo("LegalNameFieldUpdated", "LACodeFieldUpdated");
            providerVariationModel.Successors.First().Ukprn.Should().Be("provider3");
            providerVariationModel.Predecessors.First().Ukprn.Should().Be("provider1");
            providerVariationModel.Predecessors[1].Ukprn.Should().Be("provider2");
            providerVariationModel.OpenReason.Should().Be("Fresh Start");
            providerVariationModel.CloseReason.Should().Be("Closure");
        }
Ejemplo n.º 8
0
        public async Task GetNotifications_GivenAQueryStringForWhichThereAreResults_ReturnsAtomFeedWithCorrectLinks()
        {
            //Arrange
            SearchFeedV2 <AllocationNotificationFeedIndex> feeds = new SearchFeedV2 <AllocationNotificationFeedIndex>
            {
                PageRef    = 2,
                Top        = 2,
                TotalCount = 8,
                Entries    = CreateFeedIndexes()
            };
            AllocationNotificationFeedIndex firstFeedItem = feeds.Entries.ElementAt(0);

            firstFeedItem.VariationReasons = new[] { "LegalNameFieldUpdated", "LACodeFieldUpdated" };
            firstFeedItem.Successors       = new[] { "provider4" };
            firstFeedItem.Predecessors     = new[] { "provider1", "provider2" };
            firstFeedItem.OpenReason       = "Fresh Start";
            firstFeedItem.CloseReason      = "Closure";

            IAllocationNotificationsFeedsSearchService feedsSearchService = CreateSearchService();

            feedsSearchService
            .GetFeedsV2(Arg.Is(2), Arg.Is(2))
            .ReturnsForAnyArgs(feeds);

            AllocationNotificationFeedsService service = CreateService(feedsSearchService);

            IHeaderDictionary headerDictionary = new HeaderDictionary();

            headerDictionary.Add("Accept", new StringValues("application/json"));

            IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
            {
                { "pageRef", new StringValues("2") },
                { "allocationStatuses", new StringValues("Published,Approved") },
                { "pageSize", new StringValues("2") }
            });

            HttpRequest request = Substitute.For <HttpRequest>();

            request.Scheme.Returns("https");
            request.Path.Returns(new PathString("/api/v2/allocations/notifications"));
            request.Host.Returns(new HostString("wherever.naf:12345"));
            request.QueryString.Returns(new QueryString("?pageSize=2&allocationStatuses=Published&allocationStatuses=Approved"));
            request.Headers.Returns(headerDictionary);
            request.Query.Returns(queryStringValues);

            //Act
            IActionResult result = await service.GetNotifications(request, pageRef : 2, pageSize : 2, allocationStatuses : new[] { "Published", "Approved" });

            //Assert
            result
            .Should()
            .BeOfType <ContentResult>();

            ContentResult contentResult         = result as ContentResult;
            AtomFeed <AllocationModel> atomFeed = JsonConvert.DeserializeObject <AtomFeed <AllocationModel> >(contentResult.Content);

            atomFeed
            .Should()
            .NotBeNull();

            atomFeed.Id.Should().NotBeEmpty();
            atomFeed.Title.Should().Be("Calculate Funding Service Allocation Feed");
            atomFeed.Author.Name.Should().Be("Calculate Funding Service");
            atomFeed.Link.First(m => m.Rel == "next-archive").Href.Should().Be("https://wherever.naf:12345/api/v2/allocations/notifications/3?pageSize=2&allocationStatuses=Published&allocationStatuses=Approved");
            atomFeed.Link.First(m => m.Rel == "prev-archive").Href.Should().Be("https://wherever.naf:12345/api/v2/allocations/notifications/1?pageSize=2&allocationStatuses=Published&allocationStatuses=Approved");
            atomFeed.Link.First(m => m.Rel == "self").Href.Should().Be("https://wherever.naf:12345/api/v2/allocations/notifications?pageSize=2&allocationStatuses=Published&allocationStatuses=Approved");
            atomFeed.Link.First(m => m.Rel == "current").Href.Should().Be("https://wherever.naf:12345/api/v2/allocations/notifications/2?pageSize=2&allocationStatuses=Published&allocationStatuses=Approved");
            atomFeed.AtomEntry.Count.Should().Be(3);
            atomFeed.AtomEntry.ElementAt(0).Id.Should().Be("https://wherever.naf:12345/api/v2/allocations/id-1");
            atomFeed.AtomEntry.ElementAt(0).Title.Should().Be("test title 1");
            atomFeed.AtomEntry.ElementAt(0).Summary.Should().Be("test summary 1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.FundingStream.Id.Should().Be("fs-1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.FundingStream.Name.Should().Be("fs 1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Period.Id.Should().Be("fp-1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.UkPrn.Should().Be("1111");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.Upin.Should().Be("0001");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.AllocationLine.Id.Should().Be("al-1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.AllocationLine.Name.Should().Be("al 1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.AllocationStatus.Should().Be("Published");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.AllocationAmount.Should().Be(10);
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.ProfilePeriods.Should().HaveCount(0);
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.FundingStream.ShortName.Should().Be("fs-short-1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.FundingStream.PeriodType.Id.Should().Be("fspi-1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.FundingStream.PeriodType.Name.Should().Be("fspi1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.FundingStream.PeriodType.StartDay.Should().Be(1);
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.FundingStream.PeriodType.StartMonth.Should().Be(8);
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.FundingStream.PeriodType.EndDay.Should().Be(31);
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.FundingStream.PeriodType.EndMonth.Should().Be(7);
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Period.Name.Should().Be("fspi1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Period.StartYear.Should().Be(2018);
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Period.EndYear.Should().Be(2019);
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.Name.Should().Be("provider 1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.LegalName.Should().Be("legal 1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.Urn.Should().Be("01");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.DfeEstablishmentNumber.Should().Be("dfe-1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.EstablishmentNumber.Should().Be("e-1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.LaCode.Should().Be("la-1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.LocalAuthority.Should().Be("authority");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.Type.Should().Be("type 1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.SubType.Should().Be("sub type 1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.OpenDate.Should().NotBeNull();
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.CloseDate.Should().NotBeNull();
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.CrmAccountId.Should().Be("crm-1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.NavVendorNo.Should().Be("nv-1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.Status.Should().Be("Active");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.AllocationLine.ShortName.Should().Be("short-al1");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.AllocationLine.FundingRoute.Should().Be("LA");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.AllocationLine.ContractRequired.Should().Be("Y");
            atomFeed.AtomEntry.ElementAt(0).Content.Allocation.AllocationResultTitle.Should().Be("test title 1");
            ProviderVariation providerVariation1 = atomFeed.AtomEntry.ElementAt(0).Content.Allocation.Provider.ProviderVariation;

            providerVariation1.Should().NotBeNull();
            providerVariation1.VariationReasons.Should().BeEquivalentTo("LegalNameFieldUpdated", "LACodeFieldUpdated");
            providerVariation1.Successors.First().Ukprn.Should().Be("provider4");
            providerVariation1.Predecessors.First().Ukprn.Should().Be("provider1");
            providerVariation1.Predecessors[1].Ukprn.Should().Be("provider2");
            providerVariation1.OpenReason.Should().Be("Fresh Start");
            providerVariation1.CloseReason.Should().Be("Closure");

            atomFeed.AtomEntry.ElementAt(1).Id.Should().Be("https://wherever.naf:12345/api/v2/allocations/id-2");
            atomFeed.AtomEntry.ElementAt(1).Title.Should().Be("test title 2");
            atomFeed.AtomEntry.ElementAt(1).Summary.Should().Be("test summary 2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.FundingStream.Id.Should().Be("fs-2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.FundingStream.Name.Should().Be("fs 2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Period.Id.Should().Be("fp-2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.UkPrn.Should().Be("2222");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.Upin.Should().Be("0002");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.AllocationLine.Id.Should().Be("al-2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.AllocationLine.Name.Should().Be("al 2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.AllocationStatus.Should().Be("Published");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.AllocationAmount.Should().Be(100);
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.ProfilePeriods.Should().HaveCount(2);
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.FundingStream.ShortName.Should().Be("fs-short-2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.FundingStream.PeriodType.Id.Should().Be("fspi-2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.FundingStream.PeriodType.Name.Should().Be("fspi2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.FundingStream.PeriodType.StartDay.Should().Be(1);
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.FundingStream.PeriodType.StartMonth.Should().Be(8);
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.FundingStream.PeriodType.EndDay.Should().Be(31);
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.FundingStream.PeriodType.EndMonth.Should().Be(7);
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Period.Name.Should().Be("fspi2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Period.StartYear.Should().Be(2018);
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Period.EndYear.Should().Be(2019);
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.Name.Should().Be("provider 2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.LegalName.Should().Be("legal 2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.Urn.Should().Be("02");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.DfeEstablishmentNumber.Should().Be("dfe-2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.EstablishmentNumber.Should().Be("e-2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.LaCode.Should().Be("la-2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.LocalAuthority.Should().Be("authority");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.Type.Should().Be("type 2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.SubType.Should().Be("sub type 2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.OpenDate.Should().NotBeNull();
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.CloseDate.Should().NotBeNull();
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.CrmAccountId.Should().Be("crm-2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.NavVendorNo.Should().Be("nv-2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.Status.Should().Be("Active");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.AllocationLine.ShortName.Should().Be("short-al2");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.AllocationLine.FundingRoute.Should().Be("LA");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.AllocationLine.ContractRequired.Should().Be("Y");
            atomFeed.AtomEntry.ElementAt(1).Content.Allocation.AllocationResultTitle.Should().Be("test title 2");
            ProviderVariation providerVariation2 = atomFeed.AtomEntry.ElementAt(1).Content.Allocation.Provider.ProviderVariation;

            AssertProviderVariationValuesNotSet(providerVariation2);

            atomFeed.AtomEntry.ElementAt(2).Id.Should().Be("https://wherever.naf:12345/api/v2/allocations/id-3");
            atomFeed.AtomEntry.ElementAt(2).Title.Should().Be("test title 3");
            atomFeed.AtomEntry.ElementAt(2).Summary.Should().Be("test summary 3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.FundingStream.Id.Should().Be("fs-3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.FundingStream.Name.Should().Be("fs 3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Period.Id.Should().Be("fp-3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.UkPrn.Should().Be("3333");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.Upin.Should().Be("0003");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.AllocationLine.Id.Should().Be("al-3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.AllocationLine.Name.Should().Be("al 3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.AllocationStatus.Should().Be("Approved");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.AllocationAmount.Should().Be(20);
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.ProfilePeriods.Should().HaveCount(0);
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.FundingStream.ShortName.Should().Be("fs-short-3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.FundingStream.PeriodType.Id.Should().Be("fspi-3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.FundingStream.PeriodType.StartDay.Should().Be(1);
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.FundingStream.PeriodType.StartMonth.Should().Be(8);
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.FundingStream.PeriodType.EndDay.Should().Be(31);
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.FundingStream.PeriodType.EndMonth.Should().Be(7);
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Period.Name.Should().Be("fspi3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Period.StartYear.Should().Be(2018);
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Period.EndYear.Should().Be(2019);
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.Name.Should().Be("provider 3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.LegalName.Should().Be("legal 3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.Urn.Should().Be("03");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.DfeEstablishmentNumber.Should().Be("dfe-3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.EstablishmentNumber.Should().Be("e-3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.LaCode.Should().Be("la-3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.LocalAuthority.Should().Be("authority");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.Type.Should().Be("type 3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.SubType.Should().Be("sub type 3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.OpenDate.Should().NotBeNull();
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.CloseDate.Should().NotBeNull();
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.CrmAccountId.Should().Be("crm-3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.NavVendorNo.Should().Be("nv-3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.Status.Should().Be("Active");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.AllocationLine.ShortName.Should().Be("short-al3");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.AllocationLine.FundingRoute.Should().Be("LA");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.AllocationLine.ContractRequired.Should().Be("Y");
            atomFeed.AtomEntry.ElementAt(2).Content.Allocation.AllocationResultTitle.Should().Be("test title 3");
            ProviderVariation providerVariation3 = atomFeed.AtomEntry.ElementAt(2).Content.Allocation.Provider.ProviderVariation;

            AssertProviderVariationValuesNotSet(providerVariation2);
        }