public static bool TryFormatRss10Feed(Rss10Feed feed, out XDocument document, ExtensionManifestDirectory extensionManifestDirectory = null)
{
document = default;
if (feed == null)
{
return(false);
}
document = new XDocument();
var rdfElement = new XElement(_rdf + "RDF");
document.Add(rdfElement);
var namespaceAliases = new XNamespaceAliasSet();
namespaceAliases.EnsureNamespaceAlias(Rss10Constants.RdfNamespaceAlias, _rdf);
namespaceAliases.EnsureNamespaceAlias(alias: null, _rss);
if (extensionManifestDirectory == null)
{
extensionManifestDirectory = ExtensionManifestDirectory.DefaultForRss;
}
if (!TryFormatRss10Channel(feed.Channel, namespaceAliases, extensionManifestDirectory, out var channelElement))
{
return(false);
}
rdfElement.Add(channelElement);
if (TryFormatRss10Image(feed.Channel.Image, referenceOnly: false, namespaceAliases, extensionManifestDirectory, out var imageElement))
{
rdfElement.Add(imageElement);
}
if (TryFormatRss10TextInput(feed.Channel.TextInput, referenceOnly: false, namespaceAliases, extensionManifestDirectory, out var textInputElement))
{
rdfElement.Add(textInputElement);
}
foreach (var itemToFormat in feed.Channel.Items)
{
if (TryFormatRss10Item(itemToFormat, referenceOnly: false, namespaceAliases, extensionManifestDirectory, out var itemElement))
{
rdfElement.Add(itemElement);
}
}
foreach (var namespaceAlias in namespaceAliases.OrderBy(x => x.Name.LocalName))
{
rdfElement.Add(namespaceAlias);
}
return(true);
}
public void DebugPossibleNamespaceDeclarations()
{
var sampleFeeds = SampleFeedDirectory.GetSampleFeeds();
var namespaceSet = new XNamespaceAliasSet();
foreach (var feed in sampleFeeds)
{
var documentRoot = feed.XDocument?.Root;
if (documentRoot == null)
{
continue;
}
var namespaceDeclarations = documentRoot
.Attributes()
.Where(x => x.IsNamespaceDeclaration)
.ToList();
foreach (var namespaceDeclaration in namespaceDeclarations)
{
var alias = namespaceDeclaration.Name.LocalName;
if (alias == "xmlns")
{
alias = null;
}
namespaceSet.EnsureNamespaceAlias(alias, namespaceDeclaration.Value);
}
}
Debugger.Break(); // take a look at "namespaceSet"
}
private static bool TryFormatRss10ContentEncoded(string valueToFormat, XNamespaceAliasSet namespaceAliases, out XElement element)
{
element = default;
if (string.IsNullOrWhiteSpace(valueToFormat))
{
return(false);
}
namespaceAliases.EnsureNamespaceAlias(Rss10ContentExtensionConstants.NamespaceAlias, Rss10ContentExtensionConstants.Namespace);
element = new XElement(Rss10ContentExtensionConstants.Namespace + "encoded");
element.Add(new XCData(valueToFormat));
return(true);
}
private static bool TryFormatRss10SlashTextElement(string valueToFormat, string elementName, XNamespaceAliasSet namespaceAliases, out XElement element)
{
element = default;
if (string.IsNullOrWhiteSpace(valueToFormat))
{
return(false);
}
namespaceAliases.EnsureNamespaceAlias(Rss10SlashExtensionConstants.NamespaceAlias, Rss10SlashExtensionConstants.Namespace);
element = new XElement(Rss10SlashExtensionConstants.Namespace + elementName)
{
Value = valueToFormat
};
return(true);
}
private static bool TryFormatCreativeCommonsTextElement(CreativeCommonsLicense licenseToFormat, XNamespaceAliasSet namespaceAliases, out XElement licenseElement)
{
licenseElement = default;
if (string.IsNullOrWhiteSpace(licenseToFormat?.Value))
{
return(false);
}
namespaceAliases.EnsureNamespaceAlias(CreativeCommonsExtensionConstants.NamespaceAlias, CreativeCommonsExtensionConstants.Namespace);
licenseElement = new XElement(CreativeCommonsExtensionConstants.Namespace + "license")
{
Value = licenseToFormat.Value
};
return(true);
}
public static bool TryFormatMediaRssExtension(MediaRssExtension extensionToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out IList <XElement> elements)
{
elements = default;
if (extensionToFormat == null)
{
return(false);
}
elements = new List <XElement>();
// groups
foreach (var groupToFormat in extensionToFormat.Groups ?? Enumerable.Empty <MediaRssGroup>())
{
if (TryFormatMediaRssGroup(groupToFormat, namespaceAliases, extensionManifestDirectory, out var groupElement))
{
elements.Add(groupElement);
}
}
// contents
foreach (var contentToFormat in extensionToFormat.Contents ?? Enumerable.Empty <MediaRssContent>())
{
if (TryFormatMediaRssContent(contentToFormat, namespaceAliases, extensionManifestDirectory, out var contentElement))
{
elements.Add(contentElement);
}
}
// container
if (TryFormatMediaRssContainer(extensionToFormat, namespaceAliases, extensionManifestDirectory, out var containerChildElements))
{
foreach (var containerChildElement in containerChildElements)
{
elements.Add(containerChildElement);
}
}
if (!elements.Any())
{
return(false);
}
namespaceAliases.EnsureNamespaceAlias(MediaRssExtensionConstants.NamespaceAlias, _media);
return(true);
}
private static bool TryFormatRss10SyndicationUpdatePeriod(Rss10SyndicationUpdatePeriodValue?valueToFormat, XNamespaceAliasSet namespaceAliases, out XElement element)
{
element = default;
if (valueToFormat == null)
{
return(false);
}
element = new XElement(Rss10SyndicationExtensionConstants.Namespace + "updatePeriod");
string updatePeriodString;
switch (valueToFormat.Value)
{
case Rss10SyndicationUpdatePeriodValue.Hourly:
updatePeriodString = "hourly";
break;
case Rss10SyndicationUpdatePeriodValue.Daily:
updatePeriodString = "daily";
break;
case Rss10SyndicationUpdatePeriodValue.Weekly:
updatePeriodString = "weekly";
break;
case Rss10SyndicationUpdatePeriodValue.Monthly:
updatePeriodString = "monthly";
break;
case Rss10SyndicationUpdatePeriodValue.Yearly:
updatePeriodString = "yearly";
break;
default:
return(false);
}
element.Value = updatePeriodString;
namespaceAliases.EnsureNamespaceAlias(Rss10SyndicationExtensionConstants.NamespaceAlias, Rss10SyndicationExtensionConstants.Namespace);
return(true);
}
private static bool TryFormatRss10SlashHitParade(IList <int> valueToFormat, XNamespaceAliasSet namespaceAliases, out XElement element)
{
element = default;
if (valueToFormat?.Any() != true)
{
return(false);
}
var valueString = string.Join(",", valueToFormat.Select(x => x.ToString(CultureInfo.InvariantCulture)));
namespaceAliases.EnsureNamespaceAlias(Rss10SlashExtensionConstants.NamespaceAlias, Rss10SlashExtensionConstants.Namespace);
element = new XElement(Rss10SlashExtensionConstants.Namespace + "hit_parade")
{
Value = valueString
};
return(true);
}
private static bool TryFormatRss10SlashComments(int?valueToFormat, XNamespaceAliasSet namespaceAliases, out XElement element)
{
element = default;
if (valueToFormat == null)
{
return(false);
}
var valueString = valueToFormat.Value.ToString(CultureInfo.InvariantCulture);
namespaceAliases.EnsureNamespaceAlias(Rss10SlashExtensionConstants.NamespaceAlias, Rss10SlashExtensionConstants.Namespace);
element = new XElement(Rss10SlashExtensionConstants.Namespace + "comments")
{
Value = valueString
};
return(true);
}
private static bool TryFormatRssAtom10Link(Atom10Link linkToFormat, XNamespaceAliasSet namespaceAliases, out XElement linkElement)
{
linkElement = default;
if (string.IsNullOrEmpty(linkToFormat.Href))
{
return(false);
}
namespaceAliases.EnsureNamespaceAlias(RssAtom10ExtensionConstants.NamespaceAlias, RssAtom10ExtensionConstants.Namespace);
linkElement = new XElement(RssAtom10ExtensionConstants.Namespace + "link");
linkElement.Add(new XAttribute("href", linkToFormat.Href));
if (TryFormatRssAtom10OptionalTextAttribute(linkToFormat.Rel, "rel", out var relAttribute))
{
linkElement.Add(relAttribute);
}
if (TryFormatRssAtom10OptionalTextAttribute(linkToFormat.Type, "type", out var typeAttribute))
{
linkElement.Add(typeAttribute);
}
if (TryFormatRssAtom10OptionalTextAttribute(linkToFormat.Hreflang, "hreflang", out var hreflangAttribute))
{
linkElement.Add(hreflangAttribute);
}
if (TryFormatRssAtom10OptionalTextAttribute(linkToFormat.Title, "title", out var titleAttribute))
{
linkElement.Add(titleAttribute);
}
if (TryFormatRssAtom10OptionalNumericAttribute(linkToFormat.Length, "length", out var lengthAttribute))
{
linkElement.Add(lengthAttribute);
}
return(true);
}
private static bool TryFormatRss10SyndicationUpdateBase(DateTimeOffset?valueToFormat, XNamespaceAliasSet namespaceAliases, out XElement element)
{
element = default;
if (valueToFormat == null)
{
return(false);
}
if (!Rfc3339TimestampFormatter.TryFormatTimestampAsString(valueToFormat.Value, out var valueString))
{
return(false);
}
namespaceAliases.EnsureNamespaceAlias(Rss10SyndicationExtensionConstants.NamespaceAlias, Rss10SyndicationExtensionConstants.Namespace);
element = new XElement(Rss10SyndicationExtensionConstants.Namespace + "updateBase")
{
Value = valueString
};
return(true);
}
private static bool TryFormatDublinCoreTimestamp(DateTimeOffset?valueToFormat, string elementName, XNamespaceAliasSet namespaceAliases, out XElement element)
{
element = default;
if (valueToFormat == null)
{
return(false);
}
if (!Rfc3339TimestampFormatter.TryFormatTimestampAsString(valueToFormat.Value, out var valueString))
{
return(false);
}
namespaceAliases.EnsureNamespaceAlias(DublinCoreExtensionConstants.NamespaceAlias, DublinCoreExtensionConstants.Namespace);
element = new XElement(DublinCoreExtensionConstants.Namespace + elementName)
{
Value = valueString
};
return(true);
}
public static bool TryFormatAtom10Feed(Atom10Feed feed, out XDocument document, ExtensionManifestDirectory extensionManifestDirectory = null)
{
document = default;
if (feed == null)
{
return(false);
}
document = new XDocument();
var feedElement = new XElement(_atom + "feed");
document.Add(feedElement);
var namespaceAliases = new XNamespaceAliasSet();
namespaceAliases.EnsureNamespaceAlias(alias: null, _atom);
if (extensionManifestDirectory == null)
{
extensionManifestDirectory = ExtensionManifestDirectory.DefaultForAtom;
}
if (TryFormatAtom10OptionalTextAttribute(feed.Lang, _xml + "lang", out var langAttribute))
{
feedElement.Add(langAttribute);
}
if (TryFormatAtom10OptionalTextAttribute(feed.Base, _xml + "base", out var baseAttribute))
{
feedElement.Add(baseAttribute);
}
if (TryFormatAtom10RequiredTextElement(feed.Id, _atom + "id", out var idElement))
{
feedElement.Add(idElement);
}
if (TryFormatAtom10TextRequired(feed.Title, _atom + "title", out var titleElement))
{
feedElement.Add(titleElement);
}
if (TryFormatAtom10TimestampRequired(feed.Updated, _atom + "updated", out var updatedElement))
{
feedElement.Add(updatedElement);
}
foreach (var authorToFormat in feed.Authors)
{
if (TryFormatAtom10Person(authorToFormat, _atom + "author", out var authorElement))
{
feedElement.Add(authorElement);
}
}
foreach (var linkToFormat in feed.Links)
{
if (TryFormatAtom10Link(linkToFormat, out var linkElement))
{
feedElement.Add(linkElement);
}
}
foreach (var categoryToFormat in feed.Categories)
{
if (TryFormatAtom10Category(categoryToFormat, out var categoryElement))
{
feedElement.Add(categoryElement);
}
}
foreach (var contributorToFormat in feed.Contributors)
{
if (TryFormatAtom10Person(contributorToFormat, _atom + "contributor", out var contributorElement))
{
feedElement.Add(contributorElement);
}
}
if (TryFormatAtom10Generator(feed.Generator, out var generatorElement))
{
feedElement.Add(generatorElement);
}
if (TryFormatAtom10OptionalTextElement(feed.Icon, _atom + "icon", out var iconElement))
{
feedElement.Add(iconElement);
}
if (TryFormatAtom10OptionalTextElement(feed.Logo, _atom + "logo", out var logoElement))
{
feedElement.Add(logoElement);
}
if (TryFormatAtom10TextOptional(feed.Rights, _atom + "rights", out var rightsElement))
{
feedElement.Add(rightsElement);
}
if (TryFormatAtom10TextOptional(feed.Subtitle, _atom + "subtitle", out var subtitleElement))
{
feedElement.Add(subtitleElement);
}
// extensions
if (ExtensibleEntityFormatter.TryFormatXElementExtensions(feed, namespaceAliases, extensionManifestDirectory, out var extensionElements))
{
feedElement.AddRange(extensionElements);
}
// entries
foreach (var entryToFormat in feed.Entries)
{
if (TryFormatAtom10Entry(entryToFormat, namespaceAliases, extensionManifestDirectory, out var entryElement))
{
feedElement.Add(entryElement);
}
}
foreach (var namespaceAlias in namespaceAliases.OrderBy(x => x.Name.LocalName))
{
feedElement.Add(namespaceAlias);
}
return(true);
}
