/// <summary> /// Initializes the supplied <see cref="RssEnclosure"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>. /// </summary> /// <param name="enclosure">The <see cref="RssEnclosure"/> to be filled.</param> /// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the enclosure XML data.</param> /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param> /// <exception cref="ArgumentNullException">The <paramref name="enclosure"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> private static void FillEnclosure(RssEnclosure enclosure, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Validate parameters //------------------------------------------------------------ Guard.ArgumentNotNull(enclosure, "enclosure"); Guard.ArgumentNotNull(navigator, "navigator"); Guard.ArgumentNotNull(manager, "manager"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Attempt to extract enclosure information //------------------------------------------------------------ if (navigator.HasAttributes) { string urlAttribute = navigator.GetAttribute("url", String.Empty); string lengthAttribute = navigator.GetAttribute("length", String.Empty); string typeAttribute = navigator.GetAttribute("type", String.Empty); Uri url; if (Uri.TryCreate(urlAttribute, UriKind.RelativeOrAbsolute, out url)) { enclosure.Url = url; } long length; if (Int64.TryParse(lengthAttribute, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out length)) { enclosure.Length = length; } if (!String.IsNullOrEmpty(typeAttribute)) { enclosure.ContentType = typeAttribute; } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings); adapter.Fill(enclosure); }
/// <summary> /// Creates a <see cref="AtomTextConstruct"/> using the supplied <see cref="XPathNavigator"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param> /// <returns>A <see cref="AtomTextConstruct"/> instance initialized using the supplied <paramref name="source"/>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a Atom 0.3 Content construct. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> private static AtomTextConstruct CreateTextContent(XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ AtomTextConstruct content = new AtomTextConstruct(); //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); Guard.ArgumentNotNull(manager, "manager"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Attempt to extract common attributes information //------------------------------------------------------------ AtomUtility.FillCommonObjectAttributes(content, source); //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ if (source.HasAttributes) { string modeAttribute = source.GetAttribute("mode", String.Empty); if (!String.IsNullOrEmpty(modeAttribute)) { if (String.Compare(modeAttribute, "base64", StringComparison.OrdinalIgnoreCase) == 0) { content.TextType = AtomTextConstructType.Text; } else if (String.Compare(modeAttribute, "escaped", StringComparison.OrdinalIgnoreCase) == 0) { content.TextType = AtomTextConstructType.Html; } else if (String.Compare(modeAttribute, "xml", StringComparison.OrdinalIgnoreCase) == 0) { content.TextType = AtomTextConstructType.Xhtml; } else { content.TextType = AtomTextConstructType.Text; } } } if (content.TextType == AtomTextConstructType.Xhtml) { XPathNavigator xhtmlDivNavigator = source.SelectSingleNode("xhtml:div", manager); if (xhtmlDivNavigator != null && !String.IsNullOrEmpty(xhtmlDivNavigator.Value)) { content.Content = xhtmlDivNavigator.Value; } else if (!String.IsNullOrEmpty(source.Value)) { content.Content = source.Value; } } else if (!String.IsNullOrEmpty(source.Value)) { content.Content = source.Value; } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(content, manager); return content; }
/// <summary> /// Modifies the <see cref="AtomFeed"/> to match the data source. /// </summary> /// <param name="resource">The <see cref="AtomFeed"/> to be filled.</param> /// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception> public void Fill(AtomFeed resource) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(resource, "resource"); //------------------------------------------------------------ // Create namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = Atom03SyndicationResourceAdapter.CreateNamespaceManager(this.Navigator.NameTable); //------------------------------------------------------------ // Attempt to fill syndication resource //------------------------------------------------------------ XPathNavigator feedNavigator = this.Navigator.SelectSingleNode("atom:feed", manager); if (feedNavigator != null) { AtomUtility.FillCommonObjectAttributes(resource, feedNavigator); XPathNavigator idNavigator = feedNavigator.SelectSingleNode("atom:id", manager); XPathNavigator titleNavigator = feedNavigator.SelectSingleNode("atom:title", manager); XPathNavigator modifiedNavigator = feedNavigator.SelectSingleNode("atom:modified", manager); if (idNavigator != null) { resource.Id = new AtomId(); resource.Id.Load(idNavigator, this.Settings); } if (titleNavigator != null) { resource.Title = Atom03SyndicationResourceAdapter.CreateTextContent(titleNavigator, manager, this.Settings); } if (modifiedNavigator != null) { DateTime updatedOn; if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(modifiedNavigator.Value, out updatedOn)) { resource.UpdatedOn = updatedOn; } } Atom03SyndicationResourceAdapter.FillFeedOptionals(resource, feedNavigator, manager, this.Settings); Atom03SyndicationResourceAdapter.FillFeedCollections(resource, feedNavigator, manager, this.Settings); SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(feedNavigator, this.Settings); adapter.Fill(resource, manager); } }
/// <summary> /// Loads this <see cref="RssChannel"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param> /// <returns><b>true</b> if the <see cref="RssChannel"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="RssChannel"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ bool wasLoaded = false; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Create namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = new XmlNamespaceManager(source.NameTable); manager.AddNamespace("atom", "http://www.w3.org/2005/Atom"); //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ XPathNavigator descriptionNavigator = source.SelectSingleNode("description", manager); XPathNavigator linkNavigator = source.SelectSingleNode("link", manager); XPathNavigator titleNavigator = source.SelectSingleNode("title", manager); //------------------------------------------------------------ // Load required channel information //------------------------------------------------------------ if (descriptionNavigator != null && !String.IsNullOrEmpty(descriptionNavigator.Value)) { this.Description = descriptionNavigator.Value; wasLoaded = true; } if (linkNavigator != null) { Uri link; if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link)) { this.Link = link; wasLoaded = true; } } if (titleNavigator != null && !String.IsNullOrEmpty(titleNavigator.Value)) { this.Title = titleNavigator.Value; wasLoaded = true; } //------------------------------------------------------------ // Load optional channel information //------------------------------------------------------------ if (this.LoadOptionals(source, manager, settings)) { wasLoaded = true; } //------------------------------------------------------------ // Load channel collections information //------------------------------------------------------------ if (this.LoadCollections(source, manager, settings)) { wasLoaded = true; } //------------------------------------------------------------ // Load optional RSS Profile channel information //------------------------------------------------------------ if (this.LoadProfile(source, manager, settings)) { wasLoaded = true; } //------------------------------------------------------------ // Attempt to extract syndication extension information //------------------------------------------------------------ SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(this); return wasLoaded; }
/// <summary> /// Creates a <see cref="AtomGenerator"/> using the supplied <see cref="XPathNavigator"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param> /// <returns>A <see cref="AtomGenerator"/> instance initialized using the supplied <paramref name="source"/>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a Atom 0.3 generator element. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> private static AtomGenerator CreateGenerator(XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ AtomGenerator generator = new AtomGenerator(); //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); Guard.ArgumentNotNull(manager, "manager"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Attempt to extract common attributes information //------------------------------------------------------------ AtomUtility.FillCommonObjectAttributes(generator, source); //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ if(source.HasAttributes) { string urlAttribute = source.GetAttribute("url", String.Empty); string versionAttribute = source.GetAttribute("version", String.Empty); if (!String.IsNullOrEmpty(urlAttribute)) { Uri uri; if (Uri.TryCreate(urlAttribute, UriKind.RelativeOrAbsolute, out uri)) { generator.Uri = uri; } } if (!String.IsNullOrEmpty(versionAttribute)) { generator.Version = versionAttribute; } } if (!String.IsNullOrEmpty(source.Value)) { generator.Content = source.Value; } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(generator, manager); return generator; }
/// <summary> /// Loads this <see cref="OpmlOutline"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param> /// <returns><b>true</b> if the <see cref="OpmlOutline"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="OpmlOutline"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ bool wasLoaded = false; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ if (source.HasAttributes) { XPathNavigator attributesNavigator = source.CreateNavigator(); if (attributesNavigator.MoveToFirstAttribute()) { //------------------------------------------------------------ // Extract first attribute //------------------------------------------------------------ if (this.LoadAttribute(attributesNavigator)) { wasLoaded = true; } //------------------------------------------------------------ // Enumerate through additional attributes //------------------------------------------------------------ while (attributesNavigator.MoveToNextAttribute()) { if (this.LoadAttribute(attributesNavigator)) { wasLoaded = true; } } } } if (source.HasChildren) { XPathNodeIterator outlinesIterator = source.Select("outline"); if (outlinesIterator != null && outlinesIterator.Count > 0) { while (outlinesIterator.MoveNext()) { OpmlOutline outline = new OpmlOutline(); if (outline.Load(outlinesIterator.Current, settings)) { this.Outlines.Add(outline); wasLoaded = true; } } } } //------------------------------------------------------------ // Attempt to extract syndication extension information //------------------------------------------------------------ SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(this); return wasLoaded; }
/// <summary> /// Modifies the <see cref="ApmlDocument"/> to match the data source. /// </summary> /// <param name="resource">The <see cref="ApmlDocument"/> to be filled.</param> /// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception> public void Fill(ApmlDocument resource) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(resource, "resource"); //------------------------------------------------------------ // Create namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = ApmlUtility.CreateNamespaceManager(this.Navigator.NameTable); //------------------------------------------------------------ // Attempt to fill syndication resource //------------------------------------------------------------ XPathNavigator headNavigator = this.Navigator.SelectSingleNode("apml:APML/apml:Head", manager); if (headNavigator != null) { resource.Head.Load(headNavigator, this.Settings); } XPathNavigator bodyNavigator = this.Navigator.SelectSingleNode("apml:APML/apml:Body", manager); if (bodyNavigator != null) { if (bodyNavigator.HasAttributes) { string defaultProfileAttribute = bodyNavigator.GetAttribute("defaultprofile", String.Empty); if (!String.IsNullOrEmpty(defaultProfileAttribute)) { resource.DefaultProfileName = defaultProfileAttribute; } } XPathNodeIterator profileIterator = bodyNavigator.Select("apml:Profile", manager); if (profileIterator != null && profileIterator.Count > 0) { int counter = 0; while (profileIterator.MoveNext()) { ApmlProfile profile = new ApmlProfile(); counter++; if (profile.Load(profileIterator.Current, this.Settings)) { if (this.Settings.RetrievalLimit != 0 && counter > this.Settings.RetrievalLimit) { break; } ((Collection<ApmlProfile>)resource.Profiles).Add(profile); } } } XPathNodeIterator applicationIterator = bodyNavigator.Select("apml:Applications/apml:Application", manager); if (applicationIterator != null && applicationIterator.Count > 0) { while (applicationIterator.MoveNext()) { ApmlApplication application = new ApmlApplication(); if (application.Load(applicationIterator.Current, this.Settings)) { resource.Applications.Add(application); } } } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(this.Navigator.SelectSingleNode("apml:APML", manager), this.Settings); adapter.Fill(resource, manager); }
/// <summary> /// Modifies the <see cref="RssFeed"/> to match the data source. /// </summary> /// <param name="resource">The <see cref="RssFeed"/> to be filled.</param> /// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception> public void Fill(RssFeed resource) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(resource, "resource"); //------------------------------------------------------------ // Create namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = new XmlNamespaceManager(this.Navigator.NameTable); manager.AddNamespace("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); manager.AddNamespace("rss", "http://my.netscape.com/rdf/simple/0.9/"); //------------------------------------------------------------ // Attempt to fill syndication resource //------------------------------------------------------------ XPathNavigator channelNavigator = this.Navigator.SelectSingleNode("rdf:RDF/rss:channel", manager); if (channelNavigator != null) { Rss090SyndicationResourceAdapter.FillChannel(resource.Channel, channelNavigator, manager, this.Settings); } XPathNavigator imageNavigator = this.Navigator.SelectSingleNode("rdf:RDF/rss:image", manager); if (imageNavigator != null) { resource.Channel.Image = new RssImage(); Rss090SyndicationResourceAdapter.FillImage(resource.Channel.Image, imageNavigator, manager, this.Settings); } XPathNavigator textInputNavigator = this.Navigator.SelectSingleNode("rdf:RDF/rss:textinput", manager); if (textInputNavigator != null) { resource.Channel.TextInput = new RssTextInput(); Rss090SyndicationResourceAdapter.FillTextInput(resource.Channel.TextInput, textInputNavigator, manager, this.Settings); } XPathNodeIterator itemIterator = this.Navigator.Select("rdf:RDF/rss:item", manager); if (itemIterator != null && itemIterator.Count > 0) { int counter = 0; while (itemIterator.MoveNext()) { RssItem item = new RssItem(); counter++; if (this.Settings.RetrievalLimit != 0 && counter > this.Settings.RetrievalLimit) { break; } XPathNavigator titleNavigator = itemIterator.Current.SelectSingleNode("rss:title", manager); XPathNavigator linkNavigator = itemIterator.Current.SelectSingleNode("rss:link", manager); if (titleNavigator != null) { item.Title = titleNavigator.Value; } if (linkNavigator != null) { Uri link; if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link)) { item.Link = link; } } SyndicationExtensionAdapter itemExtensionAdapter = new SyndicationExtensionAdapter(itemIterator.Current, this.Settings); itemExtensionAdapter.Fill(item, manager); ((Collection<RssItem>)resource.Channel.Items).Add(item); } } SyndicationExtensionAdapter feedExtensionAdapter = new SyndicationExtensionAdapter(this.Navigator.SelectSingleNode("rdf:RDF", manager), this.Settings); feedExtensionAdapter.Fill(resource, manager); }
/// <summary> /// Loads this <see cref="ApmlProfile"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param> /// <returns><b>true</b> if the <see cref="ApmlProfile"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="ApmlProfile"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ bool wasLoaded = false; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Initialize XML namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = ApmlUtility.CreateNamespaceManager(source.NameTable); //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ if (source.HasAttributes) { string nameAttribute = source.GetAttribute("name", String.Empty); if (!String.IsNullOrEmpty(nameAttribute)) { this.Name = nameAttribute; wasLoaded = true; } } if(source.HasChildren) { XPathNavigator implicitDataNavigator = source.SelectSingleNode("apml:ImplicitData", manager); XPathNavigator explicitDataNavigator = source.SelectSingleNode("apml:ExplicitData", manager); if (implicitDataNavigator != null) { XPathNodeIterator conceptsIterator = implicitDataNavigator.Select("apml:Concepts/apml:Concept", manager); if (conceptsIterator != null && conceptsIterator.Count > 0) { while (conceptsIterator.MoveNext()) { ApmlConcept concept = new ApmlConcept(); if (concept.Load(conceptsIterator.Current, settings)) { this.ImplicitConcepts.Add(concept); wasLoaded = true; } } } XPathNodeIterator sourcesIterator = implicitDataNavigator.Select("apml:Sources/apml:Source", manager); if (sourcesIterator != null && sourcesIterator.Count > 0) { while (sourcesIterator.MoveNext()) { ApmlSource attentionSource = new ApmlSource(); if (attentionSource.Load(sourcesIterator.Current, settings)) { this.ImplicitSources.Add(attentionSource); wasLoaded = true; } } } } if (explicitDataNavigator != null) { XPathNodeIterator conceptsIterator = explicitDataNavigator.Select("apml:Concepts/apml:Concept", manager); if (conceptsIterator != null && conceptsIterator.Count > 0) { while (conceptsIterator.MoveNext()) { ApmlConcept concept = new ApmlConcept(); if (concept.Load(conceptsIterator.Current, settings)) { this.ExplicitConcepts.Add(concept); wasLoaded = true; } } } XPathNodeIterator sourcesIterator = explicitDataNavigator.Select("apml:Sources/apml:Source", manager); if (sourcesIterator != null && sourcesIterator.Count > 0) { while (sourcesIterator.MoveNext()) { ApmlSource attentionSource = new ApmlSource(); if (attentionSource.Load(sourcesIterator.Current, settings)) { this.ExplicitSources.Add(attentionSource); wasLoaded = true; } } } } } //------------------------------------------------------------ // Attempt to extract syndication extension information //------------------------------------------------------------ SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(this); return wasLoaded; }
/// <summary> /// Initializes the supplied <see cref="RssChannel"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>. /// </summary> /// <param name="channel">The <see cref="RssChannel"/> to be filled.</param> /// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the channel XML data.</param> /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param> /// <exception cref="ArgumentNullException">The <paramref name="channel"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> private static void FillChannel(RssChannel channel, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Validate parameters //------------------------------------------------------------ Guard.ArgumentNotNull(channel, "channel"); Guard.ArgumentNotNull(navigator, "navigator"); Guard.ArgumentNotNull(manager, "manager"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Load required channel information //------------------------------------------------------------ XPathNavigator descriptionNavigator = navigator.SelectSingleNode("rss:description", manager); XPathNavigator linkNavigator = navigator.SelectSingleNode("rss:link", manager); XPathNavigator titleNavigator = navigator.SelectSingleNode("rss:title", manager); if (descriptionNavigator != null && !String.IsNullOrEmpty(descriptionNavigator.Value)) { channel.Description = descriptionNavigator.Value; } if (linkNavigator != null) { Uri link; if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link)) { channel.Link = link; } } if (titleNavigator != null && !String.IsNullOrEmpty(titleNavigator.Value)) { channel.Title = titleNavigator.Value; } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings); adapter.Fill(channel); }
/// <summary> /// Initializes the supplied <see cref="RssImage"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>. /// </summary> /// <param name="image">The <see cref="RssImage"/> to be filled.</param> /// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the image XML data.</param> /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param> /// <exception cref="ArgumentNullException">The <paramref name="image"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> private static void FillImage(RssImage image, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Validate parameters //------------------------------------------------------------ Guard.ArgumentNotNull(image, "image"); Guard.ArgumentNotNull(navigator, "navigator"); Guard.ArgumentNotNull(manager, "manager"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Attempt to extract image information //------------------------------------------------------------ XPathNavigator linkNavigator = navigator.SelectSingleNode("rss:link", manager); XPathNavigator titleNavigator = navigator.SelectSingleNode("rss:title", manager); XPathNavigator urlNavigator = navigator.SelectSingleNode("rss:url", manager); if (linkNavigator != null) { Uri link; if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link)) { image.Link = link; } } if (titleNavigator != null) { if (!String.IsNullOrEmpty(titleNavigator.Value)) { image.Title = titleNavigator.Value; } } if (urlNavigator != null) { Uri url; if (Uri.TryCreate(urlNavigator.Value, UriKind.RelativeOrAbsolute, out url)) { image.Url = url; } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings); adapter.Fill(image); }
/// <summary> /// Modifies the <see cref="OpmlDocument"/> to match the data source. /// </summary> /// <param name="resource">The <see cref="OpmlDocument"/> to be filled.</param> /// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception> public void Fill(OpmlDocument resource) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(resource, "resource"); //------------------------------------------------------------ // Create namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = new XmlNamespaceManager(this.Navigator.NameTable); //------------------------------------------------------------ // Attempt to fill syndication resource //------------------------------------------------------------ XPathNavigator documentNavigator = this.Navigator.SelectSingleNode("opml", manager); if (documentNavigator != null) { XPathNavigator headNavigator = documentNavigator.SelectSingleNode("head", manager); if (headNavigator != null) { resource.Head.Load(headNavigator, this.Settings); } XPathNodeIterator outlineIterator = documentNavigator.Select("body/outline", manager); if (outlineIterator != null && outlineIterator.Count > 0) { int counter = 0; while (outlineIterator.MoveNext()) { OpmlOutline outline = new OpmlOutline(); counter++; if (outline.Load(outlineIterator.Current, this.Settings)) { if (this.Settings.RetrievalLimit != 0 && counter > this.Settings.RetrievalLimit) { break; } ((Collection<OpmlOutline>)resource.Outlines).Add(outline); } } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(documentNavigator, this.Settings); adapter.Fill(resource, manager); } }
/// <summary> /// Loads this <see cref="ApmlSource"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param> /// <returns><b>true</b> if the <see cref="ApmlSource"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="ApmlSource"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ bool wasLoaded = false; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Initialize XML namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = ApmlUtility.CreateNamespaceManager(source.NameTable); //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ if (source.HasAttributes) { string keyAttribute = source.GetAttribute("key", String.Empty); string nameAttribute = source.GetAttribute("name", String.Empty); string valueAttribute = source.GetAttribute("value", String.Empty); string typeAttribute = source.GetAttribute("type", String.Empty); string fromAttribute = source.GetAttribute("from", String.Empty); string updatedAttribute = source.GetAttribute("updated", String.Empty); if (!String.IsNullOrEmpty(keyAttribute)) { this.Key = keyAttribute; wasLoaded = true; } if (!String.IsNullOrEmpty(nameAttribute)) { this.Name = nameAttribute; wasLoaded = true; } if (!String.IsNullOrEmpty(valueAttribute)) { decimal value; if (Decimal.TryParse(valueAttribute, System.Globalization.NumberStyles.Float, System.Globalization.NumberFormatInfo.InvariantInfo, out value)) { if (value >= Decimal.MinusOne && value <= Decimal.One) { this.Value = value; wasLoaded = true; } } } if (!String.IsNullOrEmpty(typeAttribute)) { this.MimeType = typeAttribute; wasLoaded = true; } if (!String.IsNullOrEmpty(fromAttribute)) { this.From = fromAttribute; wasLoaded = true; } if (!String.IsNullOrEmpty(updatedAttribute)) { DateTime updatedOn; if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(updatedAttribute, out updatedOn)) { this.UpdatedOn = updatedOn; wasLoaded = true; } } } if (source.HasChildren) { XPathNodeIterator authorIterator = source.Select("apml:Author", manager); if (authorIterator != null && authorIterator.Count > 0) { while (authorIterator.MoveNext()) { ApmlAuthor author = new ApmlAuthor(); if (author.Load(authorIterator.Current, settings)) { this.Authors.Add(author); wasLoaded = true; } } } } //------------------------------------------------------------ // Attempt to extract syndication extension information //------------------------------------------------------------ SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(this); return wasLoaded; }
/// <summary> /// Initializes the supplied <see cref="RssItem"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>. /// </summary> /// <param name="item">The <see cref="RssItem"/> to be filled.</param> /// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the item XML data.</param> /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param> /// <exception cref="ArgumentNullException">The <paramref name="item"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> private static void FillItem(RssItem item, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Validate parameters //------------------------------------------------------------ Guard.ArgumentNotNull(item, "item"); Guard.ArgumentNotNull(navigator, "navigator"); Guard.ArgumentNotNull(manager, "manager"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Attempt to extract item information //------------------------------------------------------------ XPathNavigator titleNavigator = navigator.SelectSingleNode("title", manager); XPathNavigator linkNavigator = navigator.SelectSingleNode("link", manager); XPathNavigator descriptionNavigator = navigator.SelectSingleNode("description", manager); XPathNavigator sourceNavigator = navigator.SelectSingleNode("source", manager); XPathNodeIterator enclosureIterator = navigator.Select("enclosure", manager); XPathNodeIterator categoryIterator = navigator.Select("category", manager); if (titleNavigator != null) { item.Title = titleNavigator.Value; } if (descriptionNavigator != null) { item.Description = descriptionNavigator.Value; } if (linkNavigator != null) { Uri link; if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link)) { item.Link = link; } } if (sourceNavigator != null) { item.Source = new RssSource(); if (sourceNavigator.HasAttributes) { string urlAttribute = sourceNavigator.GetAttribute("url", String.Empty); Uri url; if (Uri.TryCreate(urlAttribute, UriKind.RelativeOrAbsolute, out url)) { item.Source.Url = url; } } if(!String.IsNullOrEmpty(sourceNavigator.Value)) { item.Source.Title = sourceNavigator.Value; } } if (enclosureIterator != null && enclosureIterator.Count > 0) { while (enclosureIterator.MoveNext()) { RssEnclosure enclosure = new RssEnclosure(); Rss092SyndicationResourceAdapter.FillEnclosure(enclosure, enclosureIterator.Current, manager, settings); item.Enclosures.Add(enclosure); } } if (categoryIterator != null && categoryIterator.Count > 0) { while (categoryIterator.MoveNext()) { RssCategory category = new RssCategory(); Rss092SyndicationResourceAdapter.FillCategory(category, categoryIterator.Current, manager, settings); item.Categories.Add(category); } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings); adapter.Fill(item); }
/// <summary> /// Modifies the <see cref="RssFeed"/> to match the data source. /// </summary> /// <param name="resource">The <see cref="RssFeed"/> to be filled.</param> /// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception> public void Fill(RssFeed resource) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(resource, "resource"); //------------------------------------------------------------ // Create namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = new XmlNamespaceManager(this.Navigator.NameTable); //------------------------------------------------------------ // Attempt to fill syndication resource //------------------------------------------------------------ XPathNavigator feedNavigator = this.Navigator.SelectSingleNode("rss", manager); if (feedNavigator != null) { XPathNavigator channelNavigator = feedNavigator.SelectSingleNode("channel", manager); if (channelNavigator != null) { Rss091SyndicationResourceAdapter.FillChannel(resource.Channel, channelNavigator, manager, this.Settings); } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(feedNavigator, this.Settings); adapter.Fill(resource, manager); } }
/// <summary> /// Modifies the <see cref="AtomServiceDocument"/> to match the data source. /// </summary> /// <param name="resource">The <see cref="AtomServiceDocument"/> to be filled.</param> /// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception> public void Fill(AtomServiceDocument resource) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(resource, "resource"); //------------------------------------------------------------ // Create namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = AtomUtility.CreateNamespaceManager(this.Navigator.NameTable); //------------------------------------------------------------ // Attempt to fill syndication resource //------------------------------------------------------------ XPathNavigator documentNavigator = this.Navigator.SelectSingleNode("app:service", manager); if (documentNavigator != null) { AtomUtility.FillCommonObjectAttributes(resource, documentNavigator); if (documentNavigator.HasChildren) { XPathNodeIterator workspaceIterator = documentNavigator.Select("app:workspace", manager); if (workspaceIterator != null && workspaceIterator.Count > 0) { while (workspaceIterator.MoveNext()) { AtomWorkspace workspace = new AtomWorkspace(); if (workspace.Load(workspaceIterator.Current, this.Settings)) { resource.AddWorkspace(workspace); } } } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(documentNavigator, this.Settings); adapter.Fill(resource, manager); } }
/// <summary> /// Modifies the <see cref="BlogMLDocument"/> to match the data source. /// </summary> /// <param name="resource">The <see cref="BlogMLDocument"/> to be filled.</param> /// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception> public void Fill(BlogMLDocument resource) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(resource, "resource"); //------------------------------------------------------------ // Create namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = BlogMLUtility.CreateNamespaceManager(this.Navigator.NameTable); //------------------------------------------------------------ // Attempt to fill syndication resource //------------------------------------------------------------ XPathNavigator blogNavigator = this.Navigator.SelectSingleNode("blog:blog", manager); if (blogNavigator != null) { if(blogNavigator.HasAttributes) { string dateCreatedAttribute = blogNavigator.GetAttribute("date-created", String.Empty); string rootUrlAttribute = blogNavigator.GetAttribute("root-url", String.Empty); if (!String.IsNullOrEmpty(dateCreatedAttribute)) { DateTime createdOn; if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(dateCreatedAttribute, out createdOn)) { resource.GeneratedOn = createdOn; } } if (!String.IsNullOrEmpty(rootUrlAttribute)) { Uri rootUrl; if (Uri.TryCreate(rootUrlAttribute, UriKind.RelativeOrAbsolute, out rootUrl)) { resource.RootUrl = rootUrl; } } } if (blogNavigator.HasChildren) { XPathNavigator titleNavigator = blogNavigator.SelectSingleNode("blog:title", manager); XPathNavigator subtitleNavigator = blogNavigator.SelectSingleNode("blog:sub-title", manager); if (titleNavigator != null) { BlogMLTextConstruct title = new BlogMLTextConstruct(); if (title.Load(titleNavigator)) { resource.Title = title; } } if (subtitleNavigator != null) { BlogMLTextConstruct subtitle = new BlogMLTextConstruct(); if (subtitle.Load(subtitleNavigator)) { resource.Subtitle = subtitle; } } BlogML20SyndicationResourceAdapter.FillDocumentCollections(resource, blogNavigator, manager, this.Settings); } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(blogNavigator, this.Settings); adapter.Fill(resource, manager); } }
/// <summary> /// Modifies the <see cref="AtomCategoryDocument"/> to match the data source. /// </summary> /// <param name="resource">The <see cref="AtomCategoryDocument"/> to be filled.</param> /// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception> public void Fill(AtomCategoryDocument resource) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(resource, "resource"); //------------------------------------------------------------ // Create namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = AtomUtility.CreateNamespaceManager(this.Navigator.NameTable); //------------------------------------------------------------ // Attempt to fill syndication resource //------------------------------------------------------------ XPathNavigator documentNavigator = this.Navigator.SelectSingleNode("app:categories", manager); if (documentNavigator != null) { AtomUtility.FillCommonObjectAttributes(resource, documentNavigator); if (documentNavigator.HasChildren) { if (documentNavigator.HasAttributes) { string fixedAttribute = documentNavigator.GetAttribute("fixed", String.Empty); string schemeAttribute = documentNavigator.GetAttribute("scheme", String.Empty); string hrefAttribute = documentNavigator.GetAttribute("href", String.Empty); if (!String.IsNullOrEmpty(fixedAttribute)) { if (String.Compare(fixedAttribute, "yes", StringComparison.OrdinalIgnoreCase) == 0) { resource.IsFixed = true; } else if (String.Compare(fixedAttribute, "no", StringComparison.OrdinalIgnoreCase) == 0) { resource.IsFixed = false; } } if (!String.IsNullOrEmpty(schemeAttribute)) { Uri scheme; if (Uri.TryCreate(schemeAttribute, UriKind.RelativeOrAbsolute, out scheme)) { resource.Scheme = scheme; } } if (!String.IsNullOrEmpty(hrefAttribute)) { Uri href; if (Uri.TryCreate(hrefAttribute, UriKind.RelativeOrAbsolute, out href)) { resource.Uri = href; } } } if (documentNavigator.HasChildren) { XPathNodeIterator categoryIterator = documentNavigator.Select("atom:category", manager); if (categoryIterator != null && categoryIterator.Count > 0) { while (categoryIterator.MoveNext()) { AtomCategory category = new AtomCategory(); if (category.Load(categoryIterator.Current, this.Settings)) { resource.AddCategory(category); } } } } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(documentNavigator, this.Settings); adapter.Fill(resource, manager); } }
/// <summary> /// Modifies the <see cref="RsdDocument"/> to match the data source. /// </summary> /// <param name="resource">The <see cref="RsdDocument"/> to be filled.</param> /// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception> public void Fill(RsdDocument resource) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(resource, "resource"); //------------------------------------------------------------ // Create namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = RsdUtility.CreateNamespaceManager(this.Navigator.NameTable); //------------------------------------------------------------ // Attempt to fill syndication resource //------------------------------------------------------------ XPathNavigator serviceNavigator = RsdUtility.SelectSafeSingleNode(this.Navigator, "rsd:rsd/rsd:service", manager); if (serviceNavigator == null) { // dasBlog places an empty default XML namespace on the <service> element, this is a hack/compromise serviceNavigator = RsdUtility.SelectSafeSingleNode(this.Navigator, "rsd:rsd/service", manager); } if (serviceNavigator != null) { XPathNavigator engineNameNavigator = RsdUtility.SelectSafeSingleNode(serviceNavigator, "rsd:engineName", manager); XPathNavigator engineLinkNavigator = RsdUtility.SelectSafeSingleNode(serviceNavigator, "rsd:engineLink", manager); XPathNavigator homePageLinkNavigator = RsdUtility.SelectSafeSingleNode(serviceNavigator, "rsd:homePageLink", manager); XPathNodeIterator apiIterator = RsdUtility.SelectSafe(serviceNavigator, "rsd:apis/rsd:api", manager); if (engineNameNavigator != null && !String.IsNullOrEmpty(engineNameNavigator.Value)) { resource.EngineName = engineNameNavigator.Value; } if (engineLinkNavigator != null) { Uri link; if (Uri.TryCreate(engineLinkNavigator.Value, UriKind.RelativeOrAbsolute, out link)) { resource.EngineLink = link; } } if (homePageLinkNavigator != null) { Uri homepage; if (Uri.TryCreate(homePageLinkNavigator.Value, UriKind.RelativeOrAbsolute, out homepage)) { resource.Homepage = homepage; } } if (apiIterator != null && apiIterator.Count > 0) { int counter = 0; while (apiIterator.MoveNext()) { RsdApplicationInterface api = new RsdApplicationInterface(); counter++; Uri link; string rpcLinkAttribute = apiIterator.Current.GetAttribute("rpcLink", String.Empty); if (Uri.TryCreate(rpcLinkAttribute, UriKind.RelativeOrAbsolute, out link)) { api.Link = link; } if (api.Load(apiIterator.Current, this.Settings) || api.Link != null) { if (this.Settings.RetrievalLimit != 0 && counter > this.Settings.RetrievalLimit) { break; } ((Collection<RsdApplicationInterface>)resource.Interfaces).Add(api); } } } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(RsdUtility.SelectSafeSingleNode(this.Navigator, "rsd:rsd", manager), this.Settings); adapter.Fill(resource, manager); }
/// <summary> /// Loads this <see cref="ApmlApplication"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param> /// <returns><b>true</b> if the <see cref="ApmlApplication"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="ApmlApplication"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ bool wasLoaded = false; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Initialize XML namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = BlogMLUtility.CreateNamespaceManager(source.NameTable); //------------------------------------------------------------ // Attempt to extract common attributes information //------------------------------------------------------------ if (BlogMLUtility.FillCommonObject(this, source, settings)) { wasLoaded = true; } //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ if(source.HasAttributes) { string postUrlAttribute = source.GetAttribute("post-url", String.Empty); string typeAttribute = source.GetAttribute("type", String.Empty); string viewsAttribute = source.GetAttribute("views", String.Empty); if (!String.IsNullOrEmpty(postUrlAttribute)) { Uri url; if (Uri.TryCreate(postUrlAttribute, UriKind.RelativeOrAbsolute, out url)) { this.Url = url; wasLoaded = true; } } if (!String.IsNullOrEmpty(typeAttribute)) { BlogMLPostType type = BlogMLPost.PostTypeByName(typeAttribute); if (type != BlogMLPostType.None) { this.PostType = type; wasLoaded = true; } } if (!String.IsNullOrEmpty(viewsAttribute)) { this.Views = viewsAttribute; wasLoaded = true; } } if (source.HasChildren) { XPathNavigator contentNavigator = source.SelectSingleNode("blog:content", manager); XPathNavigator postNameNavigator = source.SelectSingleNode("blog:post-name", manager); XPathNavigator excerptNavigator = source.SelectSingleNode("blog:excerpt", manager); if (contentNavigator != null) { BlogMLTextConstruct content = new BlogMLTextConstruct(); if (content.Load(contentNavigator, settings)) { this.Content = content; wasLoaded = true; } } if (postNameNavigator != null) { BlogMLTextConstruct name = new BlogMLTextConstruct(); if (name.Load(postNameNavigator, settings)) { this.Name = name; wasLoaded = true; } } if (excerptNavigator != null) { BlogMLTextConstruct excerpt = new BlogMLTextConstruct(); if (excerpt.Load(excerptNavigator, settings)) { this.Excerpt = excerpt; wasLoaded = true; } } if (BlogMLPost.FillPostCollections(this, source, manager, settings)) { wasLoaded = true; } } //------------------------------------------------------------ // Attempt to extract syndication extension information //------------------------------------------------------------ SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(this); return wasLoaded; }
/// <summary> /// Loads this <see cref="BlogMLAuthor"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param> /// <returns><b>true</b> if the <see cref="BlogMLAuthor"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="BlogMLAuthor"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ bool wasLoaded = false; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Attempt to extract common attributes information //------------------------------------------------------------ if (BlogMLUtility.FillCommonObject(this, source, settings)) { wasLoaded = true; } //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ if(source.HasAttributes) { string emailAttribute = source.GetAttribute("email", String.Empty); if (!String.IsNullOrEmpty(emailAttribute)) { this.EmailAddress = emailAttribute; wasLoaded = true; } } //------------------------------------------------------------ // Attempt to extract syndication extension information //------------------------------------------------------------ SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(this); return wasLoaded; }
/// <summary> /// Initializes the supplied <see cref="RssChannel"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>. /// </summary> /// <param name="channel">The <see cref="RssChannel"/> to be filled.</param> /// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the channel XML data.</param> /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param> /// <exception cref="ArgumentNullException">The <paramref name="channel"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> private static void FillChannel(RssChannel channel, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Validate parameters //------------------------------------------------------------ Guard.ArgumentNotNull(channel, "channel"); Guard.ArgumentNotNull(navigator, "navigator"); Guard.ArgumentNotNull(manager, "manager"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Load required channel information //------------------------------------------------------------ XPathNavigator descriptionNavigator = navigator.SelectSingleNode("description", manager); XPathNavigator linkNavigator = navigator.SelectSingleNode("link", manager); XPathNavigator titleNavigator = navigator.SelectSingleNode("title", manager); XPathNavigator languageNavigator = navigator.SelectSingleNode("language", manager); if (descriptionNavigator != null && !String.IsNullOrEmpty(descriptionNavigator.Value)) { channel.Description = descriptionNavigator.Value; } if (linkNavigator != null) { Uri link; if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link)) { channel.Link = link; } } if (titleNavigator != null && !String.IsNullOrEmpty(titleNavigator.Value)) { channel.Title = titleNavigator.Value; } if (languageNavigator != null && !String.IsNullOrEmpty(languageNavigator.Value)) { try { CultureInfo language = new CultureInfo(languageNavigator.Value); channel.Language = language; } catch (ArgumentException) { System.Diagnostics.Trace.TraceWarning("Rss091SyndicationResourceAdapter unable to determine CultureInfo with a name of {0}.", languageNavigator.Value); } } XPathNavigator imageNavigator = navigator.SelectSingleNode("image", manager); if (imageNavigator != null) { channel.Image = new RssImage(); Rss091SyndicationResourceAdapter.FillImage(channel.Image, imageNavigator, manager, settings); } //------------------------------------------------------------ // Load channel optional information //------------------------------------------------------------ Rss091SyndicationResourceAdapter.FillChannelOptionals(channel, navigator, manager, settings); //------------------------------------------------------------ // Load channel collections //------------------------------------------------------------ Rss091SyndicationResourceAdapter.FillChannelCollections(channel, navigator, manager, settings); SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings); adapter.Fill(channel); }
/// <summary> /// Loads this <see cref="RssImage"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param> /// <returns><b>true</b> if the <see cref="RssImage"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="RssImage"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ bool wasLoaded = false; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ wasLoaded = this.Load(source); //------------------------------------------------------------ // Attempt to extract syndication extension information //------------------------------------------------------------ SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(this); return wasLoaded; }
/// <summary> /// Initializes the supplied <see cref="RssChannel"/> collection entities using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>. /// </summary> /// <param name="channel">The <see cref="RssChannel"/> to be filled.</param> /// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the channel XML data.</param> /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param> /// <exception cref="ArgumentNullException">The <paramref name="channel"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> private static void FillChannelCollections(RssChannel channel, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Validate parameters //------------------------------------------------------------ Guard.ArgumentNotNull(channel, "channel"); Guard.ArgumentNotNull(navigator, "navigator"); Guard.ArgumentNotNull(manager, "manager"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Extract channel collections information //------------------------------------------------------------ XPathNodeIterator skipDaysIterator = navigator.Select("skipDays/day", manager); XPathNodeIterator skipHoursIterator = navigator.Select("skipHours/hour", manager); XPathNodeIterator itemIterator = navigator.Select("item", manager); if (skipDaysIterator != null && skipDaysIterator.Count > 0) { while (skipDaysIterator.MoveNext()) { if (!String.IsNullOrEmpty(skipDaysIterator.Current.Value)) { try { DayOfWeek day = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), skipDaysIterator.Current.Value, true); if (!channel.SkipDays.Contains(day)) { channel.SkipDays.Add(day); } } catch (ArgumentException) { System.Diagnostics.Trace.TraceWarning("Rss091SyndicationResourceAdapter unable to determine DayOfWeek with a name of {0}.", skipDaysIterator.Current.Value); } } } } if (skipHoursIterator != null && skipHoursIterator.Count > 0) { while (skipHoursIterator.MoveNext()) { int hour; if (Int32.TryParse(skipHoursIterator.Current.Value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out hour)) { hour = hour - 1; // Convert to zero-based range if (!channel.SkipHours.Contains(hour) && (hour >= 0 && hour <= 23)) { channel.SkipHours.Add(hour); } else { System.Diagnostics.Trace.TraceWarning("Rss091SyndicationResourceAdapter unable to add duplicate or out-of-range skip hour with a value of {0}.", hour); } } } } if (itemIterator != null && itemIterator.Count > 0) { int counter = 0; while (itemIterator.MoveNext()) { RssItem item = new RssItem(); counter++; if (settings.RetrievalLimit != 0 && counter > settings.RetrievalLimit) { break; } XPathNavigator titleNavigator = itemIterator.Current.SelectSingleNode("title", manager); XPathNavigator linkNavigator = itemIterator.Current.SelectSingleNode("link", manager); XPathNavigator descriptionNavigator = itemIterator.Current.SelectSingleNode("description", manager); if (titleNavigator != null) { item.Title = titleNavigator.Value; } if (descriptionNavigator != null) { item.Description = descriptionNavigator.Value; } if (linkNavigator != null) { Uri link; if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link)) { item.Link = link; } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(itemIterator.Current, settings); adapter.Fill(item); ((Collection<RssItem>)channel.Items).Add(item); } } }
/// <summary> /// Creates a <see cref="AtomPersonConstruct"/> using the supplied <see cref="XPathNavigator"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param> /// <returns>A <see cref="AtomPersonConstruct"/> instance initialized using the supplied <paramref name="source"/>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a Atom 0.3 Person construct. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> private static AtomPersonConstruct CreatePerson(XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ AtomPersonConstruct person = new AtomPersonConstruct(); //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); Guard.ArgumentNotNull(manager, "manager"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Attempt to extract common attributes information //------------------------------------------------------------ AtomUtility.FillCommonObjectAttributes(person, source); //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ XPathNavigator nameNavigator = source.SelectSingleNode("atom:name", manager); XPathNavigator urlNavigator = source.SelectSingleNode("atom:url", manager); XPathNavigator emailNavigator = source.SelectSingleNode("atom:email", manager); if (nameNavigator != null) { person.Name = nameNavigator.Value; } if (urlNavigator != null) { Uri uri; if (Uri.TryCreate(urlNavigator.Value, UriKind.RelativeOrAbsolute, out uri)) { person.Uri = uri; } } if (emailNavigator != null) { person.EmailAddress = emailNavigator.Value; } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(person, manager); return person; }
/// <summary> /// Initializes the supplied <see cref="RssImage"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>. /// </summary> /// <param name="image">The <see cref="RssImage"/> to be filled.</param> /// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the image XML data.</param> /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param> /// <exception cref="ArgumentNullException">The <paramref name="image"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> private static void FillImage(RssImage image, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Validate parameters //------------------------------------------------------------ Guard.ArgumentNotNull(image, "image"); Guard.ArgumentNotNull(navigator, "navigator"); Guard.ArgumentNotNull(manager, "manager"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Attempt to extract image information //------------------------------------------------------------ XPathNavigator linkNavigator = navigator.SelectSingleNode("link", manager); XPathNavigator titleNavigator = navigator.SelectSingleNode("title", manager); XPathNavigator urlNavigator = navigator.SelectSingleNode("url", manager); XPathNavigator descriptionNavigator = navigator.SelectSingleNode("description", manager); XPathNavigator heightNavigator = navigator.SelectSingleNode("height", manager); XPathNavigator widthNavigator = navigator.SelectSingleNode("width", manager); if (linkNavigator != null) { Uri link; if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link)) { image.Link = link; } } if (titleNavigator != null) { if (!String.IsNullOrEmpty(titleNavigator.Value)) { image.Title = titleNavigator.Value; } } if (urlNavigator != null) { Uri url; if (Uri.TryCreate(urlNavigator.Value, UriKind.RelativeOrAbsolute, out url)) { image.Url = url; } } if (descriptionNavigator != null) { image.Description = descriptionNavigator.Value; } if (heightNavigator != null) { int height; if (Int32.TryParse(heightNavigator.Value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out height)) { image.Height = height < RssImage.HeightMaximum ? height : RssImage.HeightMaximum; } } if (widthNavigator != null) { int width; if (Int32.TryParse(widthNavigator.Value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out width)) { image.Width = width < RssImage.WidthMaximum ? width : RssImage.WidthMaximum; } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings); adapter.Fill(image); }
/// <summary> /// Modifies the <see cref="AtomEntry"/> to match the supplied <see cref="XPathNavigator"/> data source. /// </summary> /// <param name="entry">The <see cref="AtomEntry"/> to be filled.</param> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents an Atom 0.3 element. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="entry"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> private static void FillEntry(AtomEntry entry, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(entry, "entry"); Guard.ArgumentNotNull(source, "source"); Guard.ArgumentNotNull(manager, "manager"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Attempt to fill syndication resource //------------------------------------------------------------ AtomUtility.FillCommonObjectAttributes(entry, source); XPathNavigator idNavigator = source.SelectSingleNode("atom:id", manager); XPathNavigator titleNavigator = source.SelectSingleNode("atom:title", manager); XPathNavigator modifiedNavigator = source.SelectSingleNode("atom:modified", manager); if (idNavigator != null) { entry.Id = new AtomId(); entry.Id.Load(idNavigator, settings); } if (titleNavigator != null) { entry.Title = Atom03SyndicationResourceAdapter.CreateTextContent(titleNavigator, manager, settings); } if (modifiedNavigator != null) { DateTime updatedOn; if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(modifiedNavigator.Value, out updatedOn)) { entry.UpdatedOn = updatedOn; } } Atom03SyndicationResourceAdapter.FillEntryOptionals(entry, source, manager, settings); Atom03SyndicationResourceAdapter.FillEntryCollections(entry, source, manager, settings); SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(entry, manager); }
/// <summary> /// Initializes the supplied <see cref="RssTextInput"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>. /// </summary> /// <param name="textInput">The <see cref="RssTextInput"/> to be filled.</param> /// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the text input XML data.</param> /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param> /// <exception cref="ArgumentNullException">The <paramref name="textInput"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> private static void FillTextInput(RssTextInput textInput, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Validate parameters //------------------------------------------------------------ Guard.ArgumentNotNull(textInput, "textInput"); Guard.ArgumentNotNull(navigator, "navigator"); Guard.ArgumentNotNull(manager, "manager"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Attempt to extract text input information //------------------------------------------------------------ XPathNavigator descriptionNavigator = navigator.SelectSingleNode("description", manager); XPathNavigator linkNavigator = navigator.SelectSingleNode("link", manager); XPathNavigator nameNavigator = navigator.SelectSingleNode("name", manager); XPathNavigator titleNavigator = navigator.SelectSingleNode("title", manager); if (descriptionNavigator != null) { if (!String.IsNullOrEmpty(descriptionNavigator.Value)) { textInput.Description = descriptionNavigator.Value; } } if (linkNavigator != null) { Uri link; if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link)) { textInput.Link = link; } } if (nameNavigator != null) { if (!String.IsNullOrEmpty(nameNavigator.Value)) { textInput.Name = nameNavigator.Value; } } if (titleNavigator != null) { if (!String.IsNullOrEmpty(titleNavigator.Value)) { textInput.Title = titleNavigator.Value; } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings); adapter.Fill(textInput); }
/// <summary> /// Loads this <see cref="ApmlApplication"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param> /// <returns><b>true</b> if the <see cref="ApmlApplication"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="ApmlApplication"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ bool wasLoaded = false; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Initialize XML namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = BlogMLUtility.CreateNamespaceManager(source.NameTable); //------------------------------------------------------------ // Attempt to extract common attributes information //------------------------------------------------------------ if (BlogMLUtility.FillCommonObject(this, source, settings)) { wasLoaded = true; } //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ if(source.HasAttributes) { string userNameAttribute = source.GetAttribute("user-name", String.Empty); string userEmailAttribute = source.GetAttribute("user-email", String.Empty); string userUrlAttribute = source.GetAttribute("user-url", String.Empty); if (!String.IsNullOrEmpty(userNameAttribute)) { this.UserName = userNameAttribute; wasLoaded = true; } if (!String.IsNullOrEmpty(userEmailAttribute)) { this.UserEmailAddress = userEmailAttribute; wasLoaded = true; } if (!String.IsNullOrEmpty(userUrlAttribute)) { Uri url; if (Uri.TryCreate(userUrlAttribute, UriKind.RelativeOrAbsolute, out url)) { this.UserUrl = url; wasLoaded = true; } } } if (source.HasChildren) { XPathNavigator contentNavigator = source.SelectSingleNode("blog:content", manager); if (contentNavigator != null) { BlogMLTextConstruct content = new BlogMLTextConstruct(); if (content.Load(contentNavigator)) { this.Content = content; wasLoaded = true; } } } //------------------------------------------------------------ // Attempt to extract syndication extension information //------------------------------------------------------------ SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(this); return wasLoaded; }
/// <summary> /// Initializes the supplied <see cref="RssCloud"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>. /// </summary> /// <param name="cloud">The <see cref="RssCloud"/> to be filled.</param> /// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the cloud XML data.</param> /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation of the <see cref="RssFeed"/>.</param> /// <exception cref="ArgumentNullException">The <paramref name="cloud"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> private static void FillCloud(RssCloud cloud, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Validate parameters //------------------------------------------------------------ Guard.ArgumentNotNull(cloud, "cloud"); Guard.ArgumentNotNull(navigator, "navigator"); Guard.ArgumentNotNull(manager, "manager"); Guard.ArgumentNotNull(settings, "settings"); //------------------------------------------------------------ // Attempt to extract category information //------------------------------------------------------------ if (navigator.HasAttributes) { string domainAttribute = navigator.GetAttribute("domain", String.Empty); string portAttribute = navigator.GetAttribute("port", String.Empty); string pathAttribute = navigator.GetAttribute("path", String.Empty); string registerProcedureAttribute = navigator.GetAttribute("registerProcedure", String.Empty); string protocolAttribute = navigator.GetAttribute("protocol", String.Empty); if (!String.IsNullOrEmpty(domainAttribute)) { cloud.Domain = domainAttribute; } if (!String.IsNullOrEmpty(portAttribute)) { int port; if (Int32.TryParse(portAttribute, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out port)) { cloud.Port = port; } } if (!String.IsNullOrEmpty(pathAttribute)) { cloud.Path = pathAttribute; } if (!String.IsNullOrEmpty(registerProcedureAttribute)) { cloud.RegisterProcedure = registerProcedureAttribute; } if (!String.IsNullOrEmpty(protocolAttribute)) { RssCloudProtocol protocol = RssCloud.CloudProtocolByName(protocolAttribute); if (protocol != RssCloudProtocol.None) { cloud.Protocol = protocol; } } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings); adapter.Fill(cloud); }