public static bool TryFormatXElementExtensions <T>(T entityToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out IList <XElement> elements)
where T : IExtensibleEntity
{
elements = default;
if (entityToFormat == null)
{
return(false);
}
var results = new List <XElement>();
foreach (var extensionEntity in entityToFormat.Extensions)
{
if (!extensionManifestDirectory.TryGetExtensionManifestByExtensionType(extensionEntity.GetType(), out var extensionManifest))
{
continue;
}
if (extensionManifest.TryFormatXElementExtension(extensionEntity, namespaceAliases, extensionManifestDirectory, out var extensionElements))
{
results.AddRange(extensionElements);
}
}
if (!results.Any())
{
return(false);
}
elements = results;
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"
}
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);
}
private static bool TryFormatRss10Channel(Rss10Channel channelToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out XElement channelElement)
{
channelElement = default;
if (channelToFormat == null)
{
return(false);
}
channelElement = new XElement(_rss + "channel");
channelElement.Add(new XAttribute(_rdf + "about", channelToFormat.About ?? ""));
channelElement.Add(new XElement(_rss + "title", channelToFormat.Title ?? ""));
channelElement.Add(new XElement(_rss + "link", channelToFormat.Link ?? ""));
channelElement.Add(new XElement(_rss + "description", channelToFormat.Description ?? ""));
if (TryFormatRss10Image(channelToFormat.Image, referenceOnly: true, namespaceAliases: namespaceAliases, extensionManifestDirectory, out var imageElement))
{
channelElement.Add(imageElement);
}
if (TryFormatRss10TextInput(channelToFormat.TextInput, referenceOnly: true, namespaceAliases: namespaceAliases, extensionManifestDirectory, out var textInputElement))
{
channelElement.Add(textInputElement);
}
// extensions
if (ExtensibleEntityFormatter.TryFormatXElementExtensions(channelToFormat, namespaceAliases, extensionManifestDirectory, out var extensionElements))
{
channelElement.AddRange(extensionElements);
}
// items
var liElements = new List <XElement>();
foreach (var itemToFormat in channelToFormat.Items)
{
if (TryFormatRss10Item(itemToFormat, referenceOnly: true, namespaceAliases: namespaceAliases, extensionManifestDirectory, itemElement: out var liElement))
{
liElements.Add(liElement);
}
}
if (liElements.Any())
{
var itemsElement = new XElement(_rss + "items");
var seqElement = new XElement(_rdf + "Seq");
seqElement.AddRange(liElements);
itemsElement.Add(seqElement);
channelElement.Add(itemsElement);
}
return(true);
}
private static bool TryFormatRss20Image(Rss20Image imageToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out XElement imageElement)
{
imageElement = default;
if (imageToFormat == null)
{
return(false);
}
imageElement = new XElement("image");
imageElement.Add(new XElement("url")
{
Value = imageToFormat.Url ?? ""
});
imageElement.Add(new XElement("title")
{
Value = imageToFormat.Title ?? ""
});
imageElement.Add(new XElement("link")
{
Value = imageToFormat.Link ?? ""
});
if (imageToFormat.Height != null)
{
var heightString = imageToFormat.Height.Value.ToString(CultureInfo.InvariantCulture);
imageElement.Add(new XElement("height")
{
Value = heightString
});
}
if (imageToFormat.Width != null)
{
var widthString = imageToFormat.Width.Value.ToString(CultureInfo.InvariantCulture);
imageElement.Add(new XElement("width")
{
Value = widthString
});
}
if (TryFormatOptionalTextElement(imageToFormat.Description, "description", out var descriptionElement))
{
imageElement.Add(descriptionElement);
}
// extensions
if (ExtensibleEntityFormatter.TryFormatXElementExtensions(imageToFormat, namespaceAliases, extensionManifestDirectory, out var extensionElements))
{
imageElement.AddRange(extensionElements);
}
return(true);
}
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 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 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 TryFormatMediaRssGroup(MediaRssGroup groupToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out XElement groupElement)
{
groupElement = default;
if (groupToFormat == null)
{
return(false);
}
var childElements = new List <XElement>();
// contents
foreach (var contentToFormat in groupToFormat.Contents ?? Enumerable.Empty <MediaRssContent>())
{
if (TryFormatMediaRssContent(contentToFormat, namespaceAliases, extensionManifestDirectory, out var contentElement))
{
childElements.Add(contentElement);
}
}
// container
if (TryFormatMediaRssContainer(groupToFormat, namespaceAliases, extensionManifestDirectory, out var containerChildElements))
{
foreach (var containerChildElement in containerChildElements)
{
childElements.Add(containerChildElement);
}
}
// extensions
if (ExtensibleEntityFormatter.TryFormatXElementExtensions(groupToFormat, namespaceAliases, extensionManifestDirectory, out var extensionElements))
{
childElements.AddRange(extensionElements);
}
if (!childElements.Any())
{
return(false);
}
groupElement = new XElement(_media + "group", childElements);
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);
}
public static bool TryFormatRss20Feed(Rss20Feed feed, out XDocument document, ExtensionManifestDirectory extensionManifestDirectory = null)
{
document = default;
if (feed == null)
{
return(false);
}
document = new XDocument();
var rssElement = new XElement("rss", new XAttribute("version", Rss20Constants.Version));
document.Add(rssElement);
if (extensionManifestDirectory == null)
{
extensionManifestDirectory = ExtensionManifestDirectory.DefaultForRss;
}
var namespaceAliases = new XNamespaceAliasSet();
if (!TryFormatRss20Channel(feed.Channel, namespaceAliases, extensionManifestDirectory, out var channelElement))
{
return(false);
}
rssElement.Add(channelElement);
foreach (var namespaceAlias in namespaceAliases.OrderBy(x => x.Name.LocalName))
{
rssElement.Add(namespaceAlias);
}
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);
}
protected override bool TryFormatXElementExtension(CreativeCommonsExtension extensionToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out IList <XElement> elements) => CreativeCommonsExtensionFormatter.TryFormatCreativeCommonsExtension(extensionToFormat, namespaceAliases, out elements);
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);
}
public static bool TryFormatRss10SyndicationExtension(Rss10SyndicationExtension extensionToFormat, XNamespaceAliasSet namespaceAliases, out IList <XElement> elements)
{
elements = default;
if (extensionToFormat == null)
{
return(false);
}
elements = new List <XElement>();
if (TryFormatRss10SyndicationUpdatePeriod(extensionToFormat.UpdatePeriod, namespaceAliases, out var updatePeriodElement))
{
elements.Add(updatePeriodElement);
}
if (TryFormatRss10SyndicationUpdateFrequency(extensionToFormat.UpdateFrequency, namespaceAliases, out var updateFrequencyElement))
{
elements.Add(updateFrequencyElement);
}
if (TryFormatRss10SyndicationUpdateBase(extensionToFormat.UpdateBase, namespaceAliases, out var updateBaseElement))
{
elements.Add(updateBaseElement);
}
if (!elements.Any())
{
return(false);
}
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);
}
public static bool TryFormatRss10SlashExtension(Rss10SlashExtension extensionToFormat, XNamespaceAliasSet namespaceAliases, out IList <XElement> elements)
{
elements = default;
if (extensionToFormat == null)
{
return(false);
}
elements = new List <XElement>();
if (TryFormatRss10SlashTextElement(extensionToFormat.Section, "section", namespaceAliases, out var sectionElement))
{
elements.Add(sectionElement);
}
if (TryFormatRss10SlashTextElement(extensionToFormat.Department, "department", namespaceAliases, out var departmentElement))
{
elements.Add(departmentElement);
}
if (TryFormatRss10SlashComments(extensionToFormat.Comments, namespaceAliases, out var commentsElement))
{
elements.Add(commentsElement);
}
if (TryFormatRss10SlashHitParade(extensionToFormat.HitParade, namespaceAliases, out var hitParadeElement))
{
elements.Add(hitParadeElement);
}
if (!elements.Any())
{
return(false);
}
return(true);
}
protected override bool TryFormatXElementExtension(DublinCoreExtension extensionToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out IList <XElement> elements) => DublinCoreExtensionFormatter.TryFormatDublinCoreExtension(extensionToFormat, namespaceAliases, out elements);
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);
}
private static bool TryFormatAtom10Entry(Atom10Entry entryToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out XElement entryElement)
{
entryElement = default;
if (entryToFormat == null)
{
return(false);
}
entryElement = new XElement(_atom + "entry");
if (TryFormatAtom10RequiredTextElement(entryToFormat.Id, _atom + "id", out var idElement))
{
entryElement.Add(idElement);
}
if (TryFormatAtom10TextRequired(entryToFormat.Title, _atom + "title", out var titleElement))
{
entryElement.Add(titleElement);
}
if (TryFormatAtom10TimestampRequired(entryToFormat.Updated, _atom + "updated", out var updatedElement))
{
entryElement.Add(updatedElement);
}
foreach (var authorToFormat in entryToFormat.Authors)
{
if (TryFormatAtom10Person(authorToFormat, _atom + "author", out var authorElement))
{
entryElement.Add(authorElement);
}
}
if (TryFormatAtom10Content(entryToFormat.Content, out var contentElement))
{
entryElement.Add(contentElement);
}
foreach (var linkToFormat in entryToFormat.Links)
{
if (TryFormatAtom10Link(linkToFormat, out var linkElement))
{
entryElement.Add(linkElement);
}
}
if (TryFormatAtom10TextOptional(entryToFormat.Summary, _atom + "summary", out var summaryElement))
{
entryElement.Add(summaryElement);
}
foreach (var categoryToFormat in entryToFormat.Categories)
{
if (TryFormatAtom10Category(categoryToFormat, out var categoryElement))
{
entryElement.Add(categoryElement);
}
}
foreach (var contributorToFormat in entryToFormat.Contributors)
{
if (TryFormatAtom10Person(contributorToFormat, _atom + "contributor", out var contributorElement))
{
entryElement.Add(contributorElement);
}
}
if (TryFormatAtom10TimestampOptional(entryToFormat.Published, _atom + "published", out var publishedElement))
{
entryElement.Add(publishedElement);
}
if (TryFormatAtom10TextOptional(entryToFormat.Rights, _atom + "rights", out var rightsElement))
{
entryElement.Add(rightsElement);
}
if (TryFormatAtom10Source(entryToFormat.Source, out var sourceElement))
{
entryElement.Add(sourceElement);
}
// extensions
if (ExtensibleEntityFormatter.TryFormatXElementExtensions(entryToFormat, namespaceAliases, extensionManifestDirectory, out var extensionElements))
{
entryElement.AddRange(extensionElements);
}
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 abstract bool TryFormatXElementExtension(IExtensionEntity extensionToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out IList <XElement> elements);
private static bool TryFormatMediaRssLocation(MediaRssLocation locationToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out XElement locationElement)
{
locationElement = default;
if (locationToFormat == null)
{
return(false);
}
var childObjects = new List <object>();
if (MinutesSecondsTimeSpanFormatter.TryFormatTimeAsString(locationToFormat.Start, out var startFormatted))
{
childObjects.Add(new XAttribute("start", startFormatted));
}
if (MinutesSecondsTimeSpanFormatter.TryFormatTimeAsString(locationToFormat.End, out var endFormatted))
{
childObjects.Add(new XAttribute("end", endFormatted));
}
if (!string.IsNullOrEmpty(locationToFormat.Description))
{
childObjects.Add(new XAttribute("description", locationToFormat.Description));
}
// extensions
if (ExtensibleEntityFormatter.TryFormatXElementExtensions(locationToFormat, namespaceAliases, extensionManifestDirectory, out var extensionElements))
{
childObjects.AddRange(extensionElements);
}
if (!childObjects.Any())
{
return(false);
}
locationElement = new XElement(_media + "location", childObjects);
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 TryFormatRss20TextInput(Rss20TextInput textInputToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out XElement textInputElement)
{
textInputElement = default;
if (textInputToFormat == null)
{
return(false);
}
textInputElement = new XElement("textInput");
textInputElement.Add(new XElement("title")
{
Value = textInputToFormat.Title ?? ""
});
textInputElement.Add(new XElement("description")
{
Value = textInputToFormat.Description ?? ""
});
textInputElement.Add(new XElement("name")
{
Value = textInputToFormat.Name ?? ""
});
textInputElement.Add(new XElement("link")
{
Value = textInputToFormat.Link ?? ""
});
// extensions
if (ExtensibleEntityFormatter.TryFormatXElementExtensions(textInputToFormat, namespaceAliases, extensionManifestDirectory, out var extensionElements))
{
textInputElement.AddRange(extensionElements);
}
return(true);
}
private static bool TryFormatRss20Item(Rss20Item itemToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out XElement itemElement)
{
itemElement = default;
if (itemToFormat == null)
{
return(false);
}
itemElement = new XElement("item");
if (TryFormatOptionalTextElement(itemToFormat.Title, "title", out var titleElement))
{
itemElement.Add(titleElement);
}
if (TryFormatOptionalTextElement(itemToFormat.Link, "link", out var linkElement))
{
itemElement.Add(linkElement);
}
if (TryFormatOptionalTextElement(itemToFormat.Description, "description", out var descriptionElement))
{
itemElement.Add(descriptionElement);
}
if (TryFormatOptionalTextElement(itemToFormat.Author, "author", out var authorElement))
{
itemElement.Add(authorElement);
}
if (TryFormatOptionalTextElement(itemToFormat.Comments, "comments", out var commentsElement))
{
itemElement.Add(commentsElement);
}
foreach (var categoryToFormat in itemToFormat.Categories)
{
if (TryFormatRss20Category(categoryToFormat, out var categoryElement))
{
itemElement.Add(categoryElement);
}
}
foreach (var enclosureToFormat in itemToFormat.Enclosures)
{
if (TryFormatRss20Enclosure(enclosureToFormat, out var enclosureElement))
{
itemElement.Add(enclosureElement);
}
}
if (TryFormatRss20Timestamp(itemToFormat.PubDate, "pubDate", out var pubDateElement))
{
itemElement.Add(pubDateElement);
}
if (TryFormatRss20Source(itemToFormat.Source, out var sourceElement))
{
itemElement.Add(sourceElement);
}
if (TryFormatRss20Guid(itemToFormat.Guid, out var guidElement))
{
itemElement.Add(guidElement);
}
// extensions
if (ExtensibleEntityFormatter.TryFormatXElementExtensions(itemToFormat, namespaceAliases, extensionManifestDirectory, out var extensionElements))
{
itemElement.AddRange(extensionElements);
}
return(true);
}
private static bool TryFormatMediaRssContainer(MediaRssContainer containerToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out IList <XElement> elements)
{
elements = default;
if (containerToFormat == null)
{
return(false);
}
elements = new List <XElement>();
// optional elements
foreach (var ratingToFormat in containerToFormat.Ratings ?? Enumerable.Empty <MediaRssRating>())
{
if (TryFormatMediaRssRating(ratingToFormat, out var ratingElement))
{
elements.Add(ratingElement);
}
}
if (TryFormatMediaRssTypedText(containerToFormat.Title, "title", out var titleElement))
{
elements.Add(titleElement);
}
if (TryFormatMediaRssTypedText(containerToFormat.Description, "description", out var descriptionElement))
{
elements.Add(descriptionElement);
}
if (TryFormatMediaRssKeywords(containerToFormat.Keywords, out var keywordsElement))
{
elements.Add(keywordsElement);
}
foreach (var thumbnailToFormat in containerToFormat.Thumbnails ?? Enumerable.Empty <MediaRssThumbnail>())
{
if (TryFormatMediaRssThumbnail(thumbnailToFormat, out var thumbnailElement))
{
elements.Add(thumbnailElement);
}
}
foreach (var categoryToFormat in containerToFormat.Categories ?? Enumerable.Empty <MediaRssCategory>())
{
if (TryFormatMediaRssCategory(categoryToFormat, out var categoryElement))
{
elements.Add(categoryElement);
}
}
foreach (var hashToFormat in containerToFormat.Hashes ?? Enumerable.Empty <MediaRssHash>())
{
if (TryFormatMediaRssHash(hashToFormat, out var hashElement))
{
elements.Add(hashElement);
}
}
if (TryFormatMediaRssPlayer(containerToFormat.Player, out var playerElement))
{
elements.Add(playerElement);
}
foreach (var creditToFormat in containerToFormat.Credits ?? Enumerable.Empty <MediaRssCredit>())
{
if (TryFormatMediaRssCredit(creditToFormat, out var creditElement))
{
elements.Add(creditElement);
}
}
if (TryFormatMediaRssCopyright(containerToFormat.Copyright, out var copyrightElement))
{
elements.Add(copyrightElement);
}
foreach (var textToFormat in containerToFormat.Texts ?? Enumerable.Empty <MediaRssText>())
{
if (TryFormatMediaRssText(textToFormat, out var textElement))
{
elements.Add(textElement);
}
}
foreach (var restrictionToFormat in containerToFormat.Restrictions ?? Enumerable.Empty <MediaRssRestriction>())
{
if (TryFormatMediaRssRestriction(restrictionToFormat, out var restrictionElement))
{
elements.Add(restrictionElement);
}
}
if (TryFormatMediaRssCommunity(containerToFormat.Community, out var communityElement))
{
elements.Add(communityElement);
}
if (TryFormatMediaRssStringCollectionElements(containerToFormat.Comments, "comments", "comment", out var commentsElement))
{
elements.Add(commentsElement);
}
foreach (var embedToFormat in containerToFormat.Embeds ?? Enumerable.Empty <MediaRssEmbed>())
{
if (TryFormatMediaRssEmbed(embedToFormat, out var embedElement))
{
elements.Add(embedElement);
}
}
if (TryFormatMediaRssStringCollectionElements(containerToFormat.Responses, "responses", "response", out var responsesElement))
{
elements.Add(responsesElement);
}
if (TryFormatMediaRssStringCollectionElements(containerToFormat.BackLinks, "backLinks", "backLink", out var backLinksElement))
{
elements.Add(backLinksElement);
}
if (TryFormatMediaRssStatus(containerToFormat.Status, out var statusElement))
{
elements.Add(statusElement);
}
foreach (var priceToFormat in containerToFormat.Prices ?? Enumerable.Empty <MediaRssPrice>())
{
if (TryFormatMediaRssPrice(priceToFormat, out var priceElement))
{
elements.Add(priceElement);
}
}
if (TryFormatMediaRssLink(containerToFormat.License, "license", out var licenseElement))
{
elements.Add(licenseElement);
}
foreach (var subTitleToFormat in containerToFormat.SubTitles ?? Enumerable.Empty <MediaRssLink>())
{
if (TryFormatMediaRssLink(subTitleToFormat, "subTitle", out var subTitleElement))
{
elements.Add(subTitleElement);
}
}
foreach (var peerLinkToFormat in containerToFormat.PeerLinks ?? Enumerable.Empty <MediaRssLink>())
{
if (TryFormatMediaRssLink(peerLinkToFormat, "peerLink", out var peerLinkElement))
{
elements.Add(peerLinkElement);
}
}
foreach (var locationToFormat in containerToFormat.Locations ?? Enumerable.Empty <MediaRssLocation>())
{
if (TryFormatMediaRssLocation(locationToFormat, namespaceAliases, extensionManifestDirectory, out var locationElement))
{
elements.Add(locationElement);
}
}
if (TryFormatMediaRssRights(containerToFormat.Rights, out var rightsElement))
{
elements.Add(rightsElement);
}
if (TryFormatMediaRssScenes(containerToFormat.Scenes, out var scenesElement))
{
elements.Add(scenesElement);
}
if (!elements.Any())
{
return(false);
}
return(true);
}
private static bool TryFormatRss20Channel(Rss20Channel channelToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out XElement channelElement)
{
channelElement = default;
if (channelToFormat == null)
{
return(false);
}
channelElement = new XElement("channel");
channelElement.Add(new XElement("title", channelToFormat.Title ?? ""));
channelElement.Add(new XElement("link", channelToFormat.Link ?? ""));
channelElement.Add(new XElement("description", channelToFormat.Description ?? ""));
if (TryFormatOptionalTextElement(channelToFormat.Language, "language", out var languageElement))
{
channelElement.Add(languageElement);
}
if (TryFormatOptionalTextElement(channelToFormat.Copyright, "copyright", out var copyrightElement))
{
channelElement.Add(copyrightElement);
}
if (TryFormatOptionalTextElement(channelToFormat.ManagingEditor, "managingEditor", out var managingEditorElement))
{
channelElement.Add(managingEditorElement);
}
if (TryFormatOptionalTextElement(channelToFormat.WebMaster, "webMaster", out var webMasterElement))
{
channelElement.Add(webMasterElement);
}
if (TryFormatOptionalTextElement(channelToFormat.Generator, "generator", out var generatorElement))
{
channelElement.Add(generatorElement);
}
if (TryFormatOptionalTextElement(channelToFormat.Docs, "docs", out var docsElement))
{
channelElement.Add(docsElement);
}
if (TryFormatRss20Timestamp(channelToFormat.PubDate, "pubDate", out var pubDateElement))
{
channelElement.Add(pubDateElement);
}
if (TryFormatRss20Timestamp(channelToFormat.LastBuildDate, "lastBuildDate", out var lastBuildDateElement))
{
channelElement.Add(lastBuildDateElement);
}
foreach (var categoryToFormat in channelToFormat.Categories)
{
if (TryFormatRss20Category(categoryToFormat, out var categoryElement))
{
channelElement.Add(categoryElement);
}
}
if (TryFormatRss20Cloud(channelToFormat.Cloud, out var cloudElement))
{
channelElement.Add(cloudElement);
}
if (TryFormatRss20Ttl(channelToFormat.Ttl, out var ttlElement))
{
channelElement.Add(ttlElement);
}
if (TryFormatRss20Image(channelToFormat.Image, namespaceAliases, extensionManifestDirectory, out var imageElement))
{
channelElement.Add(imageElement);
}
if (TryFormatRss20TextInput(channelToFormat.TextInput, namespaceAliases, extensionManifestDirectory, out var textInputElement))
{
channelElement.Add(textInputElement);
}
if (TryFormatRss20SkipHours(channelToFormat.SkipHours, out var skipHoursElement))
{
channelElement.Add(skipHoursElement);
}
if (TryFormatRss20SkipDays(channelToFormat.SkipDays, out var skipDaysElement))
{
channelElement.Add(skipDaysElement);
}
// extensions
if (ExtensibleEntityFormatter.TryFormatXElementExtensions(channelToFormat, namespaceAliases, extensionManifestDirectory, out var extensionElements))
{
channelElement.AddRange(extensionElements);
}
// items
foreach (var itemToFormat in channelToFormat.Items)
{
if (TryFormatRss20Item(itemToFormat, namespaceAliases, extensionManifestDirectory, out var itemElement))
{
channelElement.Add(itemElement);
}
}
return(true);
}
private static bool TryFormatMediaRssContent(MediaRssContent contentToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out XElement contentElement)
{
contentElement = default;
if (contentToFormat == null)
{
return(false);
}
var childElements = new List <XElement>();
var attributes = new List <XAttribute>();
// content fields
if (!string.IsNullOrEmpty(contentToFormat.Url))
{
attributes.Add(new XAttribute("url", contentToFormat.Url));
}
if (contentToFormat.FileSize != null)
{
attributes.Add(new XAttribute("fileSize", contentToFormat.FileSize.Value.ToString(CultureInfo.InvariantCulture)));
}
if (!string.IsNullOrEmpty(contentToFormat.Type))
{
attributes.Add(new XAttribute("type", contentToFormat.Type));
}
if (contentToFormat.Medium != null)
{
attributes.Add(new XAttribute("medium", contentToFormat.Medium.Value.ToString().ToLowerInvariant()));
}
if (contentToFormat.IsDefault != null)
{
attributes.Add(new XAttribute("isDefault", contentToFormat.IsDefault.Value ? "true" : "false"));
}
if (contentToFormat.Expression != MediaRssExpression.Full)
{
attributes.Add(new XAttribute("expression", contentToFormat.Expression.ToString().ToLowerInvariant()));
}
if (contentToFormat.BitRate != null)
{
attributes.Add(new XAttribute("bitrate", contentToFormat.BitRate.Value.ToString("0.####", CultureInfo.InvariantCulture)));
}
if (contentToFormat.FrameRate != null)
{
attributes.Add(new XAttribute("framerate", contentToFormat.FrameRate.Value.ToString("0.####", CultureInfo.InvariantCulture)));
}
if (contentToFormat.SamplingRate != null)
{
attributes.Add(new XAttribute("samplingrate", contentToFormat.SamplingRate.Value.ToString("0.####", CultureInfo.InvariantCulture)));
}
if (contentToFormat.Channels != null)
{
attributes.Add(new XAttribute("channels", contentToFormat.Channels.Value.ToString(CultureInfo.InvariantCulture)));
}
if (contentToFormat.Duration != null)
{
attributes.Add(new XAttribute("duration", contentToFormat.Duration.Value.TotalSeconds.ToString("0.####", CultureInfo.InvariantCulture)));
}
if (contentToFormat.Height != null)
{
attributes.Add(new XAttribute("height", contentToFormat.Height.Value.ToString(CultureInfo.InvariantCulture)));
}
if (contentToFormat.Width != null)
{
attributes.Add(new XAttribute("width", contentToFormat.Width.Value.ToString(CultureInfo.InvariantCulture)));
}
if (!string.IsNullOrEmpty(contentToFormat.Lang))
{
attributes.Add(new XAttribute("lang", contentToFormat.Lang));
}
// container
if (TryFormatMediaRssContainer(contentToFormat, namespaceAliases, extensionManifestDirectory, out var containerChildElements))
{
foreach (var containerChildElement in containerChildElements)
{
childElements.Add(containerChildElement);
}
}
// extensions
if (ExtensibleEntityFormatter.TryFormatXElementExtensions(contentToFormat, namespaceAliases, extensionManifestDirectory, out var extensionElements))
{
childElements.AddRange(extensionElements);
}
if (!childElements.Any() && !attributes.Any())
{
return(false);
}
contentElement = new XElement(_media + "content", attributes);
contentElement.AddRange(childElements);
return(true);
}
public static bool TryFormatCreativeCommonsExtension(CreativeCommonsExtension extensionToFormat, XNamespaceAliasSet namespaceAliases, out IList <XElement> elements)
{
elements = default;
if (extensionToFormat == null)
{
return(false);
}
elements = new List <XElement>();
foreach (var licenseToFormat in extensionToFormat.Licenses)
{
if (TryFormatCreativeCommonsTextElement(licenseToFormat, namespaceAliases, out var licenseElement))
{
elements.Add(licenseElement);
}
}
if (!elements.Any())
{
return(false);
}
return(true);
}
