public async Task <IActionResult> AddRssFeed(FeedBaseModel feed)
{
var user = await _authenticator.VerifyClaim(HttpContext.Request.Cookies["sessionKey"]);
if (user == null)
{
return(new ForbidResult());
}
if (!Enum.IsDefined(typeof(ApiType), feed.ApiType))
{
return(new ConflictResult());
}
return(new ObjectResult(await _feedService.CreateAsync(feed.ToFeed(user))));
}
public IActionResult GetFeedById(string id)
{
var parts = id?.Split('_');
if (parts == null || parts.Length == 0)
{
return(NotFound());
}
if (parts[0].Equals("DSG", StringComparison.InvariantCultureIgnoreCase))
{
FeedBaseModel data = null;
if (parts[0].Equals("DSG", StringComparison.InvariantCultureIgnoreCase))
{
data = GenerateDSGFunding.GetFeedEntry(id);
}
else if (parts[0].Equals("PESports", StringComparison.InvariantCultureIgnoreCase))
{
data = GeneratePESportsFunding.GetFeedEntry(id);
}
return(data == null?NotFound() : (IActionResult)Ok(data));
}
else if (parts[0].Equals("PESports", StringComparison.InvariantCultureIgnoreCase))
{
var data = GeneratePESportsFunding.GetFeedEntry(id);
if (data == null)
{
return(NotFound());
}
return(Ok(data));
}
return(NotFound());
}
/// <summary>
/// Process org groups into feed models.
/// </summary>
/// <param name="orgGroups">List of org groups.</param>
/// <param name="providerType">The provider types we are looking at.</param>
/// <param name="financialYearPeriod1920">Data about the first financial period.</param>
/// <param name="financialYearPeriod2021">Data about the second financial period.</param>
/// <param name="period">Period to use.</param>
/// <param name="stream">Stream to use.</param>
/// <param name="schemaVersion">Schema version number.</param>
/// <param name="fundingVersion">Funding version number.</param>
/// <param name="organisationGroupIdentifiers">Optional - The group identifiers to limit by (e.g. UKPRN 12345678).</param>
/// <param name="organisationIdentifiers">Optional - The organisation identifiers to limit to (e.g. UKPRN 12345678).</param>
/// <param name="organisationTypes">Optional - The organisation types to return.</param>
/// <param name="variationReasons">Optional - Filter to only organisations with these variation reasons types</param>
/// <param name="ukprns">Optional - Only get these UKPRNs back.</param>
/// <param name="fundingLineTypes">Optional - limit the types of lines we want to get back (e.g. Information and/or Payment).</param>
/// <param name="templateLineIds">Optional - Filter the lines to these ids only.</param>
/// <returns>A list of feed response models.</returns>
private static List <FeedResponseContentModel> ProcessOrgGroups(List <OrgGroup> orgGroups, string providerType, FundingPeriod financialYearPeriod1920,
FundingPeriod financialYearPeriod2021, FundingPeriod period, StreamWithTemplateVersion stream, string schemaVersion, string fundingVersion,
OrganisationIdentifier[] organisationGroupIdentifiers, OrganisationIdentifier[] organisationIdentifiers, OrganisationType[] organisationTypes,
VariationReason[] variationReasons, string[] ukprns, FundingLineType[] fundingLineTypes, string[] templateLineIds)
{
var returnList = new List <FeedResponseContentModel>();
// Limit by org group identifiers
if (organisationGroupIdentifiers?.Any() == true)
{
foreach (var organisationGroupIdentifier in organisationGroupIdentifiers)
{
orgGroups = orgGroups.Where(orgGroup => orgGroup.Type != organisationGroupIdentifier.Type.ToString() ||
orgGroup.Code == organisationGroupIdentifier.Value).ToList();
}
}
// Limit by org identifiers
if (organisationIdentifiers?.Any() == true)
{
foreach (var orgGroup in orgGroups)
{
orgGroup.Providers = orgGroup.Providers.Where(provider =>
organisationIdentifiers.Any(oi => oi.Type != OrganisationIdentifierType.LACode || oi.Value == provider.LaEstablishmentNo)).ToList();
}
}
foreach (var orgGroup in orgGroups)
{
var orgType = providerType == "NonMaintainedSpecialSchools" || providerType == "Academies" ?
(providerType == "NonMaintainedSpecialSchools" ? OrganisationType.Provider : OrganisationType.AcademyTrust) : OrganisationType.LocalAuthority;
var ukprn = $"MOCKUKPRN{orgGroup.Code}";
var groupingOrg = ConvertToOrganisationGroup(orgGroup, ukprn, orgType);
var id = $"{stream.Code}_{period.Code}_{groupingOrg.Type}_{ukprn}_{fundingVersion}";
var data = new FeedBaseModel
{
SchemaUri = "http://example.org/#schema",
SchemaVersion = schemaVersion,
Funding = new FundingFeed
{
Id = id,
FundingStream = stream,
FundingPeriod = period,
OrganisationGroup = groupingOrg,
FundingVersion = fundingVersion.Replace("-", "."),
ExternalPublicationDate = new DateTimeOffset(2019, 9, 1, 0, 0, 0, new TimeSpan(1, 0, 0)),
PaymentDate = DateTimeOffset.Now,
Status = FundingStatus.Released,
StatusChangedDate = DateTimeOffset.Now,
GroupingReason = GroupingReason.Payment,
ProviderFundings = GetProviderFundingIds(orgGroup, period, stream, fundingVersion, organisationTypes, variationReasons, ukprns),
FundingValue = new FundingValue
{
TotalValue = orgGroup.TotalAllocation,
FundingValueByDistributionPeriod = new List <FundingValueByDistributionPeriod>
{
new FundingValueByDistributionPeriod
{
DistributionPeriodCode = financialYearPeriod1920.Code,
Value = orgGroup.OctoberTotal,
FundingLines = new List <FundingLine>
{
new FundingLine
{
Name = "Total funding line",
TemplateLineId = 1,
Type = FundingLineType.Payment,
Value = orgGroup.OctoberTotal,
ProfilePeriods = new List <FundingLinePeriod>
{
new FundingLinePeriod
{
Occurence = 1,
Year = 2019,
TypeValue = "October",
ProfiledValue = orgGroup.OctoberTotal,
Type = FundingLinePeriodType.CalendarMonth,
PeriodCode = financialYearPeriod1920.Code
}
},
}
}
},
new FundingValueByDistributionPeriod
{
DistributionPeriodCode = financialYearPeriod2021.Code,
Value = orgGroup.AprilTotal,
FundingLines = new List <FundingLine>
{
new FundingLine
{
Name = "Total funding line",
TemplateLineId = 2,
Type = FundingLineType.Payment,
Value = orgGroup.AprilTotal,
ProfilePeriods = new List <FundingLinePeriod>
{
new FundingLinePeriod
{
Occurence = 1,
Year = 2020,
TypeValue = "April",
ProfiledValue = orgGroup.AprilTotal,
Type = FundingLinePeriodType.CalendarMonth,
PeriodCode = financialYearPeriod2021.Code
}
}
}
}
}
}
}
},
};
if (fundingLineTypes?.Any() == true)
{
foreach (var dperiod in data.Funding.FundingValue.FundingValueByDistributionPeriod)
{
dperiod.FundingLines = dperiod.FundingLines.Where(line => fundingLineTypes.Contains(line.Type)).ToList();
//TODO - filter at lower levels
}
}
if (templateLineIds?.Any() == true)
{
foreach (var dperiod in data.Funding.FundingValue.FundingValueByDistributionPeriod)
{
dperiod.FundingLines = dperiod.FundingLines.Where(line => templateLineIds.Contains(line.TemplateLineId.ToString())).ToList();
//TODO - filter at lower levels
}
}
var host = "http://example.org";
returnList.Add(new FeedResponseContentModel
{
Content = data,
Id = data.Funding.Id,
Author = new FeedResponseAuthor
{
Email = "*****@*****.**",
Name = "Calculate Funding Service"
},
Title = data.Funding.Id,
Updated = DateTime.Now,
Link = new FeedLink[]
{
new FeedLink
{
Href = $"{host}/api/funding/feed/byId/{data.Funding.Id}",
Rel = "self"
}
}
});
}
;
return(returnList);
}
