Esempio n. 1
0
        public async Task ReadPerson()
        {
            using (XmlReader xmlReader = XmlReader.Create(@"..\..\..\TestFeeds\simpleAtomFeed.xml", new XmlReaderSettings {
                Async = true
            }))
            {
                var persons = new List <ISyndicationPerson>();
                var reader  = new AtomFeedReader(xmlReader);
                while (await reader.Read())
                {
                    if (reader.ElementType == SyndicationElementType.Person)
                    {
                        ISyndicationPerson person = await reader.ReadPerson();

                        persons.Add(person);
                    }
                }

                Assert.True(persons.Count() == 2);
                Assert.True(persons[0].Name == "Mark Pilgrim");
                Assert.True(persons[0].Email == "*****@*****.**");
                Assert.True(persons[0].Uri == "http://example.org/");
                Assert.True(persons[1].Name == "Sam Ruby");
            }
        }
Esempio n. 2
0
        private static async Task <List <object> > ParseExport(XmlReader xmlReader)
        {
            List <object> result = new List <object>();
            {
                var feedReader = new AtomFeedReader(xmlReader);
                while (await feedReader.Read())
                {
                    switch (feedReader.ElementType)
                    {
                    // Read category
                    case SyndicationElementType.Category:
                        ISyndicationCategory category = await feedReader.ReadCategory();

                        result.Add(category);
                        break;

                    // Read Image
                    case SyndicationElementType.Image:
                        ISyndicationImage image = await feedReader.ReadImage();

                        result.Add(image);
                        break;

                    // Read Item
                    case SyndicationElementType.Item:
                        ISyndicationItem item = await feedReader.ReadItem();

                        result.Add(item);
                        break;

                    // Read link
                    case SyndicationElementType.Link:
                        ISyndicationLink link = await feedReader.ReadLink();

                        result.Add(link);
                        break;

                    // Read Person
                    case SyndicationElementType.Person:
                        ISyndicationPerson person = await feedReader.ReadPerson();

                        result.Add(person);
                        break;

                    // Read content
                    default:
                        ISyndicationContent content = await feedReader.ReadContent();

                        result.Add(content);
                        break;
                    }
                }

                return(result);
            }
        }
        private async Task <List <BlogPost> > GetFeed()
        {
            var xmlReader = XmlReader.Create(_settings.Value.FeedUrl);
            var reader    = new AtomFeedReader(xmlReader);

            var posts = new List <BlogPost>();

            //
            // Read the feed
            while (await reader.Read())
            {
                //
                // Check the type of the current element.
                switch (reader.ElementType)
                {
                //
                // Read category
                case SyndicationElementType.Category:
                    ISyndicationCategory category = await reader.ReadCategory();

                    break;

                //
                // Read image
                case SyndicationElementType.Image:
                    ISyndicationImage image = await reader.ReadImage();

                    break;

                //
                // Read entry
                case SyndicationElementType.Item:
                    IAtomEntry entry = await reader.ReadEntry();

                    // these are the only ones we need for now
                    posts.Add(new BlogPost
                    {
                        Title         = entry.Title,
                        PublishedDate = entry.Published.DateTime,
                        Categories    = entry.Categories?.Select(c => c.Name)?.ToList()
                    });
                    break;

                //
                // Read link
                case SyndicationElementType.Link:
                    ISyndicationLink link = await reader.ReadLink();

                    break;

                //
                // Read person
                case SyndicationElementType.Person:
                    ISyndicationPerson person = await reader.ReadPerson();

                    break;

                //
                // Read content
                default:
                    ISyndicationContent content = await reader.ReadContent();

                    break;
                }
            }

            return(posts);
        }
Esempio n. 4
0
    public static async Task ReadAtomFeed(string filePath)
    {
        //
        // Create an XmlReader from file
        // Example: ..\tests\TestFeeds\simpleAtomFeed.xml
        using (XmlReader xmlReader = XmlReader.Create(filePath, new XmlReaderSettings()
        {
            Async = true
        }))
        {
            //
            // Create an AtomFeedReader
            var reader = new AtomFeedReader(xmlReader);

            //
            // Read the feed
            while (await reader.Read())
            {
                //
                // Check the type of the current element.
                switch (reader.ElementType)
                {
                //
                // Read category
                case SyndicationElementType.Category:
                    ISyndicationCategory category = await reader.ReadCategory();

                    break;

                //
                // Read image
                case SyndicationElementType.Image:
                    ISyndicationImage image = await reader.ReadImage();

                    break;

                //
                // Read entry
                case SyndicationElementType.Item:
                    IAtomEntry entry = await reader.ReadEntry();

                    break;

                //
                // Read link
                case SyndicationElementType.Link:
                    ISyndicationLink link = await reader.ReadLink();

                    break;

                //
                // Read person
                case SyndicationElementType.Person:
                    ISyndicationPerson person = await reader.ReadPerson();

                    break;

                //
                // Read content
                default:
                    ISyndicationContent content = await reader.ReadContent();

                    break;
                }
            }
        }
    }
Esempio n. 5
0
        /// <summary>
        /// Reads the Atom feed at <see cref="ReleaseUpdateUri"/> and fills the <see cref="Releases"/>
        /// collection with information. If a release with higher version number than <see cref="ApplicationVersion"/>
        /// is found then the <see cref="ReleaseToUpdate"/> is set to this release.
        /// </summary>
        /// <param name="force"></param>
        /// <returns></returns>
        public async Task <bool> CheckForUpdate(bool force = false)
        {
            EnsureUpdateEntry();
            if (updateEntry.LastCheck == DateTime.Today && !force)
            {
                return(false);
            }
            try
            {
                using (var cl = new HttpClient())
                {
                    var response = await cl.GetAsync(ReleaseUpdateUri);

                    response.EnsureSuccessStatusCode();
                    using (var xmlReader = XmlReader.Create(await response.Content.ReadAsStreamAsync(),
                                                            new XmlReaderSettings
                    {
                        Async = true
                    }))
                    {
                        Releases.Clear();
                        ReleaseToUpdate = null;
                        var feedReader = new AtomFeedReader(xmlReader);

                        while (await feedReader.Read())
                        {
                            switch (feedReader.ElementType)
                            {
                            case SyndicationElementType.Category:
                                await feedReader.ReadCategory();

                                break;

                            case SyndicationElementType.Image:
                                await feedReader.ReadImage();

                                break;

                            case SyndicationElementType.Item:
                                var entry = await feedReader.ReadEntry();

                                var r = new Release();
                                r.DownloadUri = entry.Links.FirstOrDefault(x => x.RelationshipType == "alternate")?.Uri;
                                if (r.DownloadUri != null)
                                {
                                    r.Updated       = entry.LastUpdated.ToUniversalTime().LocalDateTime;
                                    r.ParsedVersion = ParseVersion(r.DownloadUri.AbsolutePath);
                                    if (r.ParsedVersion != null)
                                    {
                                        Releases.Add(r);
                                    }
                                }

                                break;

                            case SyndicationElementType.Link:
                                await feedReader.ReadLink();

                                break;

                            case SyndicationElementType.Person:
                                await feedReader.ReadPerson();

                                break;

                            default:
                                await feedReader.ReadContent();

                                break;
                            }
                        }

                        if (Releases.Count == 0)
                        {
                            return(false);
                        }
                        var top = Releases.OrderByDescending(x => x.ParsedVersion).First();
                        if (top.ParsedVersion > ApplicationVersion)
                        {
                            ReleaseToUpdate = top;
                            return(true);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogException(ex);
                return(false);
            }
            updateEntry.LastCheck = DateTime.Today;
            SaveUpdateEntry();
            return(false);
        }