Наследование: ISyndicationItem, ISyndicationNode
 private string CutHtmlMetaFromDescription(SyndicationItem syndicationItem)
 {
     var description = syndicationItem.Summary.Text;
     description = Regex.Replace(description, @"<.+?>", string.Empty);
     description = WebUtility.HtmlDecode(description);
     return description;
 }
Пример #2
0
        public static void ParseSyndicationItem(this RssItem item, SyndicationFeed syndicFeed, SyndicationItem syndicItem)
        {
            item.Title = syndicItem.Title.Text;
            item.PubDate = syndicItem.PublishedDate.DateTime;
            item.Author = syndicItem.Authors.Count > 0 ? syndicItem.Authors[0].Name.ToString() : "";
            if (syndicItem.Id.StartsWith("http"))
            {
                item.Link = syndicItem.Id;
            }
            else if (syndicItem.Links.Count > 0)
            {
                item.Link = syndicItem.Links[0].Uri.OriginalString;
            }

            item.ParseImage(syndicItem.NodeValue);

            if (syndicFeed.SourceFormat == SyndicationFormat.Atom10)
            {
                item.Content = HtmlUtilities.ConvertToText(syndicItem.Content.Text);
            }
            else if (syndicFeed.SourceFormat == SyndicationFormat.Rss20)
            {
                item.Content = HtmlUtilities.ConvertToText(syndicItem.Summary.Text);
            }
        }
Пример #3
0
		private FeedDataEntry _ReadFeedDataEntryFrom (SyndicationItem syndicationItem, SyndicationFormat syndicationFormat)
		{
			var feedDataEntry = new FeedDataEntry ();
			if (syndicationItem.Title != null && syndicationItem.Title.Text != null) {
				feedDataEntry.Title = syndicationItem.Title.Text;
			}
			if (syndicationItem.PublishedDate != null) {
				feedDataEntry.PublishedDate = syndicationItem.PublishedDate.DateTime;
			}
			if (syndicationItem.Authors != null && syndicationItem.Authors.Count > 0) {
				feedDataEntry.Author = syndicationItem.Authors[0].Name.ToString ();
			}
			switch (syndicationFormat) {
			case SyndicationFormat.Atom10: {
					if (syndicationItem.Content != null && syndicationItem.Content.Text != null) {
						feedDataEntry.Content = syndicationItem.Content.Text;
					}
					if (syndicationItem.Id != null) {
						feedDataEntry.Link = new Uri (syndicationItem.Id);
					}
					break;
				}
			case SyndicationFormat.Rss20: {
					if (syndicationItem.Summary != null && syndicationItem.Summary.Text != null) {
						feedDataEntry.Content = syndicationItem.Summary.Text;
					}
					if (syndicationItem.Links != null && syndicationItem.Links.Count > 0) {
						feedDataEntry.Link = syndicationItem.Links[0].Uri;
					}
					break;
				}
			}
			return feedDataEntry;
		}
Пример #4
0
        public FeedItem(SyndicationItem si)
        {
            _si = si;
            _title = si.Title.Text;
            _summary = si.Summary.Text;

            var doc = si.GetXmlDocument(SyndicationFormat.Rss20);
            var nodes = doc.DocumentElement.GetElementsByTagName("content");
            if (nodes.Length > 0)
            {
                var node = (XmlElement)nodes.First();
                var typeAttr = (XmlAttribute)node.Attributes.GetNamedItem("type");
                if (typeAttr != null && typeAttr.Value.Equals("image/jpeg"))
                {
                    typeAttr = (XmlAttribute)node.Attributes.GetNamedItem("url");
                    if (typeAttr != null)
                    {
                        _imageUri = new Uri(typeAttr.Value);
                    }
                }
            }

            if (si.Links.Count > 0)
            {
                _link = si.Links[0].Uri;
            }
        }
Пример #5
0
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
        public async Task<ViewModel.NewsItem> CreateItem(ViewModel.NewsItem result, SyndicationItem item)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
        {
            if (!string.IsNullOrEmpty(result.ContentRaw))
                result.ContentRaw = string.Format(GenericHtml.HTML, result.ContentRaw);
            else if (!string.IsNullOrEmpty(result.Content))
                result.ContentRaw = string.Format(GenericHtml.HTML, result.Content);


            return result;
        }
        private void TryGetImageSource(SyndicationItem syndicationItem, out Uri imageSource)
        {
            foreach (var link in syndicationItem.Links)
            {
                if (!link.MediaType.Contains("image")) continue;
                imageSource = link.Uri;
                return;
            }

            imageSource = null;
        }
        public PodcastItemViewModel(SyndicationItem item)
        {
            OriginalUri = item.GetPodcastUris().First();
            DatePublished = item.PublishedDate;
            Title = item.Title.Text;

	        string summary = item.Summary.IfNotNull(its => its.Text);
            
            Summary = summary;
            Id = new PodcastId(this.GetStorageUrl());

            PlayPodcastCommand = ReactiveCommand.Create();
            PlayPodcastCommand.Subscribe(OnPlayPodcast);

            _cachingState = FileCache.Instance.CachedFiles.FirstOrDefaultAsync(x => x.Id == Id).Select(x => new CachingStateVm(x.State)).ToProperty(this, x => x.CachingState);
        }
Пример #8
0
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
        public async Task<ViewModel.NewsItem> CreateItem(ViewModel.NewsItem result, SyndicationItem item)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
        {
            result.URIToSource = item.Id;

            if (!string.IsNullOrEmpty(result.ContentRaw))
            {
                HtmlDocument doc = new HtmlDocument();
                doc.LoadHtml(result.ContentRaw);
                
                foreach (HtmlNode link in doc.DocumentNode.Descendants("img"))
                {
                    int width = Convert.ToInt32(link.Attributes["width"]?.Value ?? "9999");
                    int height = Convert.ToInt32(link.Attributes["height"]?.Value ?? "9999");

                    if (width > 10 && height > 10)
                    {
                        result.Image = link.Attributes["src"].Value; break;
                    }
                }

                result.Content = "";

                var p = doc.DocumentNode.Descendants("p").FirstOrDefault();
                if (p != null)
                {
                    result.Content = HtmlEntity.DeEntitize(p.InnerText).Replace("\n", "").Replace("\r\n", "").Trim();
                }

                if (string.IsNullOrWhiteSpace(result.Content))
                {
                    result.Content = HtmlEntity.DeEntitize(doc.DocumentNode.InnerText).Replace("\n", "").Replace("\r\n", "").Trim();
                }

                if (!string.IsNullOrEmpty(result.Content))
                {
                    result.Content = result.Content.Length > MAX_NEWS_LEN ? result.Content.Substring(0, MAX_NEWS_LEN) : result.Content;
                }

                // Format Raw
                result.ContentRaw = string.Format(GenericHtml.HTML, result.ContentRaw);
            }

            return result;
        }
Пример #9
0
 /// <summary>
 /// Initializes the object after deserialization.
 /// </summary>
 /// <param name="item">Atom item.</param>
 internal void Initialize(SyndicationItem item)
 {
     Name = item.Title.Text;
     Uri = new Uri(item.Id);
 }
Пример #10
0
        private static AddQuestionResult UpdateQuestion(string website, SyndicationItem item)
        {
            if (!questionsCollection.ContainsKey(item.Id))
            {
                Debug.WriteLine("{0} Skipped question.", item.Id);
                return AddQuestionResult.None;
            }

            JsonObject questionObject = questionsCollection.GetNamedObject(item.Id);
            AddQuestionResult result = AddQuestionResult.None;

            string oldTitle = questionObject.GetNamedStringOrEmptyString("Title");
            string newTitle = item.Title != null ? item.Title.Text : String.Empty;
            if (oldTitle != newTitle)
            {
                questionObject.SetNamedValue("Title", JsonValue.CreateStringValue(newTitle));
                Debug.WriteLine("{0} Updated question. Different title.", item.Id);
                result = AddQuestionResult.Updated;
            }

            string oldSummary = questionObject.GetNamedStringOrEmptyString(SummaryKey);
            string newSummary = item.Summary != null ? item.Summary.Text : String.Empty;
            if (oldSummary != newSummary)
            {
                questionObject.SetNamedValue(SummaryKey, JsonValue.CreateStringValue(newTitle));
                Debug.WriteLine("{0} Updated question. Different summary.", item.Id);
                result = AddQuestionResult.Updated;
            }

            Debug.WriteLineIf(
                result == AddQuestionResult.None,
                String.Format("{0} Skipped question. Up to date.", item.Id));

            return result;
        }
Пример #11
0
        // NOTE: Adding a single question does not load or save settings. Good for performance.
        private static AddQuestionResult AddQuestion(string websiteUrl, SyndicationItem item)
        {
            // If the latestPubDate validation was skipped, it could happend that que query returns
            // questions we already have.
            if (questionsCollection.ContainsKey(item.Id))
            {
                return UpdateQuestion(websiteUrl, item);
            }

            JsonObject questionObject = new JsonObject();

            string title = item.Title != null ? item.Title.Text : String.Empty;
            string summary = item.Summary != null ? item.Summary.Text : String.Empty;

            questionObject.Add("Website", JsonValue.CreateStringValue(websiteUrl));
            questionObject.Add("Title", JsonValue.CreateStringValue(title));
            questionObject.Add(SummaryKey, JsonValue.CreateStringValue(summary));

            // TODO: Do we need to use PublishedDate.ToLocalTime(), or can we just work with the standard time?
            questionObject.Add("PubDate", JsonValue.CreateStringValue(item.PublishedDate.ToString()));

            if (item.Links.Count > 0)
            {
                questionObject.Add("Link", JsonValue.CreateStringValue(item.Links[0].Uri.AbsoluteUri));
            }

            JsonValue nullValue = JsonValue.Parse("null");
            JsonObject categoriesCollection = new JsonObject();
            foreach (SyndicationCategory category in item.Categories)
            {
                categoriesCollection.Add(category.Term, nullValue);
            }
            questionObject.Add("Categories", categoriesCollection);

            questionsCollection.Add(item.Id, questionObject);

            Debug.WriteLine("{0} New question. PubDate is {1}.", item.Id, item.PublishedDate);
            return AddQuestionResult.Added;
        }
Пример #12
0
        public async Task<ViewModel.NewsItem> CreateItem(ViewModel.NewsItem result, SyndicationItem item)
        {
            result.URIToSource = item.Id;
            
            if (!string.IsNullOrEmpty(result.ContentRaw))
            {
                HtmlDocument doc = new HtmlDocument();
                doc.LoadHtml(result.ContentRaw);
                foreach (HtmlNode link in doc.DocumentNode.Descendants("img"))
                {
                    result.Image = link.Attributes["src"].Value; break;
                }
                
                result.Content = HtmlEntity.DeEntitize(doc.DocumentNode.InnerText);
                result.ContentRaw = null;
            }

            HtmlDocument site = null;
            HtmlWeb web = new HtmlWeb();
            try { site = await web.LoadFromWebAsync(result.URIToSource); }
            catch { }

            if (site != null)
            {
                var contentNode = site.DocumentNode.Descendants("div").Where(A => A.Attributes["class"]?.Value?.Contains("formatted") ?? false).FirstOrDefault();

                HtmlNode imagecontainer;
                while ((imagecontainer = site.DocumentNode.Descendants("a").Where(A => A.Attributes["class"]?.Value?.Contains("golem-gallery2-nojs") ?? false).FirstOrDefault()) != null)
                {

                    string imageHtml = "<div>\n";
                    var imagesFromContainer = imagecontainer.Descendants("img");
                    foreach (var img in imagesFromContainer)
                    {
                        img.Attributes["src"].Value = img.Attributes["data-src-full"]?.Value ?? img.Attributes["data-src"]?.Value;
                        img.Attributes.Append("style", "max-width:600px");
                        imageHtml += img.OuterHtml + "<br/>\n";
                    }
                    imageHtml += "</div>\n";
                    var imagesNode = HtmlNode.CreateNode(imageHtml);
                    contentNode.ReplaceChild(imagesNode, imagecontainer);
                }


                if (contentNode != null && !string.IsNullOrEmpty(contentNode.InnerText) && !string.IsNullOrWhiteSpace(HtmlEntity.DeEntitize(contentNode.InnerText)))
                {
                    var nodes = contentNode.Elements("div").ToList();
                    foreach (var delNode in nodes)
                    {
                        contentNode.ChildNodes.Remove(delNode);
                    }

                    result.ContentRaw = string.Format(GenericHtml.HTML, contentNode.InnerHtml);
                }

                Func<string, string> getMetaContentByName = (string name) => site.DocumentNode.Descendants("meta")
                    ?.Where(A => A.Attributes["name"]?.Value?.ToLower() == name && !string.IsNullOrEmpty(A.Attributes["content"]?.Value))
                    ?.FirstOrDefault()?.Attributes["content"]?.Value;

                var twitter_image_src = getMetaContentByName("twitter:image:src");

                if (!string.IsNullOrEmpty(twitter_image_src))
                    result.Image = twitter_image_src;
            }

            return result;
        }
Пример #13
0
        /// <summary>
        /// Create each item from the SyndicationItem. Necesary to format the Content property with RemoveUnusedElementsAsync
        /// </summary>
        /// <param name="item"></param>
        /// <param name="format"></param>
        /// <param name="i"></param>
        /// <returns></returns>
        private FeedItem CreateFeedItem(SyndicationItem item, SyndicationFormat format, int i)
        {
            if (item == null) throw new ArgumentNullException(nameof(item));
            var feedItem = new FeedItem {Format = format};

            if (item.Title != null)
                feedItem.Title = item.Title.Text;

            feedItem.PubDate = item.PublishedDate.DateTime;
            feedItem.PubDateShow = ApiHelper.GetCustomFormattedDate(item.PublishedDate.DateTime);

            foreach (var author in item.Authors)
            {
                feedItem.Author = author.NodeValue;
            }

            if (format == SyndicationFormat.Atom10)
            {
                feedItem.Content = item.Content.Text;
            }
            else if (format == SyndicationFormat.Rss20)
            {
                feedItem.Content = item.Summary.Text;
            }

            feedItem.ImageUrl = GeekyHelper.ExtractFirstImageFromHtml(feedItem.Content);
            feedItem.Content = string.Empty;

            if (item.Links.Count > 0)
            {
                feedItem.Link = item.Links.FirstOrDefault().Uri;
            }
            
            if (i == 0 || i == 1)
            {
                feedItem.ColSpan = 2;
                feedItem.RowSpan = 2;
            }
            else
            {
                feedItem.ColSpan = 1;
                feedItem.RowSpan = 1;
            }
            
            return feedItem;
        }
Пример #14
0
 private static string GetImageFromPostContents(SyndicationItem item)
 {
     return Regex.Matches(item.Summary.Text,
             "href\\s*=\\s*(?:\"(?<1>[^\"]*)\"|(?<1>\\S+))",
             RegexOptions.None)
         .Cast<Match>()
         .Where(m =>
         {
             Uri url;
             if (Uri.TryCreate(m.Groups[1].Value, UriKind.Absolute, out url))
             {
                 string ext = Path.GetExtension(url.AbsolutePath).ToLower();
                 if (ext == ".png" || ext == ".jpg") return true;
             }
             return false;
         })
         .Select(m => m.Groups[1].Value)
         .FirstOrDefault();
 }
        /// <summary>
        /// Extracts a single queue from the given response.
        /// </summary>
        /// <param name="response">HTTP response.</param>
        /// <returns>Queue data.</returns>
        private QueueInfo GetQueue(HttpResponseMessage response)
        {
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(response.Content.ReadAsStringAsync().Result);

            SyndicationItem feedItem = new SyndicationItem();
            feedItem.LoadFromXml(doc);
            return SerializationHelper.DeserializeItem<QueueInfo>(feedItem, (item, queue) => queue.Initialize(item));
        }
Пример #16
0
        // Submit an item.
        private async void SubmitItem_Click(object sender, RoutedEventArgs e)
        {
            outputField.Text = "";

            // Since the value of 'ServiceAddressField' was provided by the user it is untrusted input. We'll validate
            // it by using Uri.TryCreate().
            // Note that this app has both "Internet (Client)" and "Home and Work Networking" capabilities set, since
            // the user may provide URIs for servers located on the intErnet or intrAnet. If apps only communicate
            // with servers on the intErnet, only the "Internet (Client)" capability should be set. Similarly if an
            // app is only intended to communicate on the intrAnet, only the "Home and Work Networking" capability should be set.
            Uri serviceUri;
            if (!Uri.TryCreate(ServiceAddressField.Text.Trim() + CommonData.ServiceDocUri, UriKind.Absolute, out serviceUri))
            {
                rootPage.NotifyUser("Invalid URI.", NotifyType.ErrorMessage);
                return;
            }

            // The title cannot be an empty string or a string with white spaces only, since it is used also
            // as the resource description (Slug header).
            if (String.IsNullOrWhiteSpace(titleField.Text))
            {
                rootPage.NotifyUser("Post title cannot be blank.", NotifyType.ErrorMessage);
                return;
            }

            rootPage.NotifyUser("Performing operation...", NotifyType.StatusMessage);
            outputField.Text = "Fetching Service document: " + serviceUri + "\r\n";

            try
            {
                // The result here is usually the same as:
                // Uri resourceUri = new Uri(ServiceAddressField.Text.Trim() + Common.EditUri);
                Uri resourceUri = await FindEditUri(serviceUri);

                if (resourceUri == null)
                {
                    rootPage.NotifyUser("URI not found in service document.", NotifyType.ErrorMessage);
                    return;
                }

                outputField.Text += "Uploading Post: " + resourceUri + "\r\n";

                SyndicationItem item = new SyndicationItem();
                item.Title = new SyndicationText(titleField.Text, SyndicationTextType.Text);
                item.Content = new SyndicationContent(contentField.Text, SyndicationTextType.Html);

                SyndicationItem result = await CommonData.GetClient().CreateResourceAsync(resourceUri, item.Title.Text, item);

                outputField.Text += "Posted at " + result.ItemUri + "\r\n";
                rootPage.NotifyUser("New post created.", NotifyType.StatusMessage);
            }
            catch (Exception ex)
            {
                if (!CommonData.HandleException(ex, outputField, rootPage))
                {
                    throw;
                }
            }
        }
Пример #17
0
        public static FeedItem Create(Int32 parentId, SyndicationItem item)
        {
            var feedItem = new FeedItem()
            {
                ParentId = parentId,
                ItemUri = item.Id,
                Title = item.Title.Text,
                Summary = item.Summary.Text,
                PublishedDate = new DateTime(item.PublishedDate.Ticks)
            };

            var links = from link in item.Links where link.MediaType.CompareTo("audio/mpeg") == 0 select link;

            if (links.Any())
            {
                feedItem.MediaUri = links.FirstOrDefault().Uri.ToString();
            }

            return feedItem;
        }
        // Update the current item.
        private async void UpdateItem_Click(object sender, RoutedEventArgs e)
        {
            if (!feedIterator.HasElements())
            {
                outputField.Text += "No item currently displayed, please download a feed first.\r\n";
                return;
            }

            rootPage.NotifyUser("Updating item...", NotifyType.StatusMessage);
            outputField.Text += "Item location: " + feedIterator.GetEditUri() + "\r\n";

            try
            {
                // Update the item
                SyndicationItem updatedItem = new SyndicationItem();
                updatedItem.Title = new SyndicationText(titleField.Text, SyndicationTextType.Text);
                updatedItem.Content = new SyndicationContent(contentField.Text, SyndicationTextType.Html);

                await CommonData.GetClient().UpdateResourceAsync(feedIterator.GetEditUri(), updatedItem);

                rootPage.NotifyUser("Updating item completed.", NotifyType.StatusMessage);
            }
            catch (Exception ex)
            {
                if (!CommonData.HandleException(ex, outputField, rootPage))
                {
                    throw;
                }
            }
        }
Пример #19
0
        private Uri GetImageUrl(SyndicationItem item)
        {
            // get category
            var category = item.Categories.FirstOrDefault();
            if (category != null)
            {
                var typeName = category.Term.Substring(category.Term.LastIndexOf('.') + 1);
                if (item.Content.Type.Equals("application/xml"))
                {
                    var properties = item.Content.Xml;
                    foreach (var p in properties.FirstChild.ChildNodes)
                    {
                        var annotation =
                            _annotations.FirstOrDefault(a => a.Target.Equals(typeName + "/" + p.LocalName) &&
                                                             a.Property.Equals(Annotation.IsThumnbnailUrl));

                        if (annotation != null) return new Uri(p.InnerText);
                    }
                } else
                {
                    
                }
            }
            return null;
        }