Пример #1
0
        private async void FillEntryItemFromXmlAtom10(FeedEntryItem entItem, XmlNode entryNode, XmlNamespaceManager atomNsMgr, string feedId)
        {
            // TODO:
            AtomEntry entry = await CreateAtomEntryFromXmlAtom(entryNode, atomNsMgr, feedId);

            entItem.Name = entry.Name;
            //entItem.ID = entry.ID;
            entItem.EntryId = entry.EntryId;
            //entItem.EditUri = entry.EditUri;
            entItem.AltHtmlUri = entry.AltHtmlUri;
            entItem.Published  = entry.Published;
            entItem.Author     = entry.Author;
            entItem.Summary    = entry.Summary;
            //entItem.SummaryPlainText = entry.SummaryPlainText;
            entItem.Content     = entry.Content;
            entItem.ContentType = entry.ContentType;
            // entItem.EntryBody = entry;

            entItem.Status = FeedEntryItem.ReadStatus.rsNew;

            if (entItem.ContentType == EntryItem.ContentTypes.textHtml)
            {
                // gets image Uri
                if (entItem.ImageUri == null)
                {
                    entItem.ImageUri = await GetImageUriFromHtml(entItem.Content);
                }
            }
        }
Пример #2
0
        private async void FillEntryItemFromXmlAtom03(FeedEntryItem entItem, XmlNode entryNode, XmlNamespaceManager atomNsMgr)
        {
            XmlNode entryTitle = entryNode.SelectSingleNode("atom:title", atomNsMgr);

            if (entryTitle != null)
            {
                entItem.Name = entryTitle.InnerText;
            }

            XmlNode entryID = entryNode.SelectSingleNode("atom:id", atomNsMgr);

            if (entryID != null)
            {
                entItem.EntryId = entryID.InnerText;
            }

            XmlNodeList entryLinkUris = entryNode.SelectNodes("atom:link", atomNsMgr);
            string      relAttr;
            string      hrefAttr;
            string      typeAttr;

            Uri altUri = null;

            if (entryLinkUris != null)
            {
                foreach (XmlNode u in entryLinkUris)
                {
                    relAttr  = (u.Attributes["rel"] != null) ? u.Attributes["rel"].Value : "";
                    hrefAttr = (u.Attributes["href"] != null) ? u.Attributes["href"].Value : "";
                    typeAttr = (u.Attributes["type"] != null) ? u.Attributes["type"].Value : "";

                    if (!string.IsNullOrEmpty(hrefAttr))
                    {
                        switch (relAttr)
                        {
                        case "service.post":
                            try
                            {
                                //editUri = new Uri(hrefAttr);
                                break;
                            }
                            catch
                            {
                                break;
                            }

                        case "alternate":
                            try
                            {
                                if (!string.IsNullOrEmpty(typeAttr))
                                {
                                    if (typeAttr == "text/html")
                                    {
                                        try
                                        {
                                            altUri = new Uri(hrefAttr);
                                        }
                                        catch (Exception e)
                                        {
                                            Debug.WriteLine("Exception @new Uri(altUri) @ FeedClient Atom0.3" + "(" + entItem.Name + ")" + " : " + e.Message);
                                        }
                                    }
                                }
                                break;
                            }
                            catch
                            {
                                break;
                            }

                        case "":     //same as alternate
                            try
                            {
                                if (!string.IsNullOrEmpty(typeAttr))
                                {
                                    if (typeAttr == "text/html")
                                    {
                                        try
                                        {
                                            altUri = new Uri(hrefAttr);
                                        }
                                        catch (Exception e)
                                        {
                                            Debug.WriteLine("Exception @new Uri(altUri) @ FeedClient Atom0.3" + "(" + entItem.Name + ")" + " : " + e.Message);
                                        }
                                    }
                                }
                                else
                                {
                                    try
                                    {
                                        // I am not happy but let's assume it is html.
                                        altUri = new Uri(hrefAttr);
                                    }
                                    catch (Exception e)
                                    {
                                        Debug.WriteLine("Exception @new Uri(altUri) @ FeedClient Atom0.3" + "(" + entItem.Name + ")" + " : " + e.Message);
                                    }
                                }
                                break;
                            }
                            catch
                            {
                                break;
                            }
                        }
                    }
                }
            }

            //entItem.EditUri = editUri;
            entItem.AltHtmlUri = altUri;

            XmlNode entryPublished = entryNode.SelectSingleNode("atom:issued", atomNsMgr);

            if (entryPublished != null)
            {
                if (!string.IsNullOrEmpty(entryPublished.InnerText))
                {
                    try
                    {
                        entItem.Published = XmlConvert.ToDateTime(entryPublished.InnerText, XmlDateTimeSerializationMode.Local);
                    }
                    catch (Exception e)
                    {
                        Debug.WriteLine("Exception @XmlConvert.ToDateTime in the Atom 0.3 feed " + "(" + entItem.Name + ")" + " : " + e.Message);
                    }
                }
            }

            string      entryAuthor  = "";
            XmlNodeList entryAuthors = entryNode.SelectNodes("atom:author", atomNsMgr);

            if (entryAuthors != null)
            {
                foreach (XmlNode auth in entryAuthors)
                {
                    XmlNode authName = auth.SelectSingleNode("atom:name", atomNsMgr);
                    if (authName != null)
                    {
                        if (string.IsNullOrEmpty(entryAuthor))
                        {
                            entryAuthor = authName.InnerText;
                        }
                        else
                        {
                            entryAuthor += "/" + authName.InnerText;
                        }
                    }
                }
            }

            if (string.IsNullOrEmpty(entryAuthor))
            {
                if (altUri != null)
                {
                    entryAuthor = altUri.Host;
                }
            }

            entItem.Author = entryAuthor;

            XmlNode cont = entryNode.SelectSingleNode("atom:content", atomNsMgr);

            if (cont == null)
            {
                string contype = cont.Attributes["type"].Value;
                if (!string.IsNullOrEmpty(contype))
                {
                    //entItem.ContentTypeString = contype;

                    switch (contype)
                    {
                    case "text":
                        entItem.ContentType = EntryItem.ContentTypes.text;
                        break;

                    case "html":
                        entItem.ContentType = EntryItem.ContentTypes.textHtml;
                        break;

                    case "xhtml":
                        entItem.ContentType = EntryItem.ContentTypes.textHtml;
                        break;

                    case "text/plain":
                        entItem.ContentType = EntryItem.ContentTypes.text;
                        break;

                    case "text/html":
                        entItem.ContentType = EntryItem.ContentTypes.textHtml;
                        break;

                    case "text/x-markdown":
                        entItem.ContentType = EntryItem.ContentTypes.markdown;
                        break;

                    case "text/x-hatena-syntax":
                        entItem.ContentType = EntryItem.ContentTypes.hatena;
                        break;

                    default:
                        entItem.ContentType = EntryItem.ContentTypes.text;
                        break;
                    }
                }

                entItem.Content = cont.InnerText;
            }

            XmlNode sum = entryNode.SelectSingleNode("atom:summary", atomNsMgr);

            if (sum != null)
            {
                entItem.Summary = await StripStyleAttributes(sum.InnerText);

                //entry.ContentType = EntryFull.ContentTypes.textHtml;

                if (!string.IsNullOrEmpty(entItem.Summary))
                {
                    entItem.Summary = await StripHtmlTags(entItem.Summary);

                    //entItem.SummaryPlainText = Truncate(sum.InnerText, 78);
                }
            }
            else
            {
                string s = entItem.Content;

                if (!string.IsNullOrEmpty(s))
                {
                    if (entItem.ContentType == EntryItem.ContentTypes.textHtml)
                    {
                        entItem.Summary = await StripHtmlTags(s);

                        //entItem.SummaryPlainText = Truncate(s, 78);
                    }
                    else if (entItem.ContentType == EntryItem.ContentTypes.text)
                    {
                        entItem.Summary = s;
                        //entItem.SummaryPlainText = Truncate(s, 78);
                    }
                }
            }

            entItem.Status = FeedEntryItem.ReadStatus.rsNew;

            if (entItem.ContentType == EntryItem.ContentTypes.textHtml)
            {
                // gets image Uri
                entItem.ImageUri = await GetImageUriFromHtml(entItem.Content);
            }
        }
Пример #3
0
        private async void FillEntryItemFromXmlRss(FeedEntryItem entItem, XmlNode entryNode, XmlNamespaceManager NsMgr)
        {
            XmlNode entryTitle = entryNode.SelectSingleNode("title");

            entItem.Name = (entryTitle != null) ? entryTitle.InnerText : "";

            XmlNode entryId = entryNode.SelectSingleNode("guid");

            entItem.EntryId = (entryId != null) ? entryId.InnerText : "";

            XmlNode entryLinkUri = entryNode.SelectSingleNode("link");

            try
            {
                if (entryLinkUri != null)
                {
                    if (!string.IsNullOrEmpty(entryLinkUri.InnerText))
                    {
                        entItem.AltHtmlUri = new Uri(entryLinkUri.InnerText);
                    }
                }
            }
            catch (Exception e)
            {
                ToDebugWindow(">> Exception @FeedClient@FillEntryItemFromXmlRss:new Uri()"
                              + Environment.NewLine +
                              "RSS feed entry (" + entItem.Name + ") contain invalid entry Uri: " + e.Message +
                              Environment.NewLine);
            }

            if (string.IsNullOrEmpty(entItem.EntryId))
            {
                if (entItem.AltHtmlUri != null)
                {
                    entItem.EntryId = entItem.AltHtmlUri.AbsoluteUri;
                }
            }

            XmlNode entryPudDate = entryNode.SelectSingleNode("pubDate");

            if (entryPudDate != null)
            {
                string s = entryPudDate.InnerText;
                if (!string.IsNullOrEmpty(s))
                {
                    try
                    {
                        DateTimeOffset dtf = DateTimeParser.ParseDateTimeRFC822(s);

                        entItem.Published = dtf.ToUniversalTime().DateTime;
                    }
                    catch (Exception e)
                    {
                        // Debug.WriteLine("Exception @ParseDateTimeRFC822 in the RSS 2.0 feed " + "("+ entItem.Name  + ")" + " : " + e.Message);

                        ToDebugWindow(">> Exception @FeedClient@FillEntryItemFromXmlRss:ParseDateTimeRFC822()"
                                      + Environment.NewLine +
                                      "RSS feed entry(" + entItem.Name + ") contain invalid entry pubDate (DateTimeRFC822 expected): " + e.Message +
                                      Environment.NewLine);

                        // TODO: really shouldn't to cover these invalid format, but...for the usability stand point...
                        try
                        {
                            DateTime tmp;
                            if (DateTime.TryParse(s, out tmp))
                            {
                                entItem.Published = tmp.ToUniversalTime();
                            }
                        }
                        catch { }
                    }
                }
            }

            string      entryAuthor  = "";
            XmlNodeList entryAuthors = entryNode.SelectNodes("dc:creator", NsMgr);

            if (entryAuthors != null)
            {
                foreach (XmlNode auth in entryAuthors)
                {
                    if (string.IsNullOrEmpty(entryAuthor))
                    {
                        entryAuthor = auth.InnerText;
                    }
                    else
                    {
                        entryAuthor += "/" + auth.InnerText;
                    }
                }
            }

            if (string.IsNullOrEmpty(entryAuthor))
            {
                if (entItem.AltHtmlUri != null)
                {
                    entryAuthor = entItem.AltHtmlUri.Host;
                }
            }

            entItem.Author = entryAuthor;

            // gets imageUri from enclosure
            XmlNode enclosure = entryNode.SelectSingleNode("enclosure");

            if (enclosure != null)
            {
                if (enclosure.Attributes["url"] != null)
                {
                    string urlImage = enclosure.Attributes["url"].Value;

                    if (enclosure.Attributes["type"] != null)
                    {
                        string imageType = enclosure.Attributes["type"].Value;

                        if ((imageType == "image/jpg") || (imageType == "image/jpeg") || (imageType == "image/png") || (imageType == "image/gif"))
                        {
                            try
                            {
                                entItem.ImageUri = new Uri(urlImage);
                            }
                            catch (Exception e)
                            {
                                ToDebugWindow(">> Exception @FeedClient@FillEntryItemFromXmlRss:new Uri()"
                                              + Environment.NewLine +
                                              "RSS feed entry (" + entItem.Name + ") contain invalid entry > enclosure@link Uri: " + e.Message +
                                              Environment.NewLine);
                            }
                        }
                    }
                }
            }

            // Force textHtml for RSS feed. Even though description was missing. (needs this for browser)
            entItem.ContentType = EntryItem.ContentTypes.textHtml;

            XmlNode sum = entryNode.SelectSingleNode("description");

            if (sum != null)
            {
                // Content
                entItem.Content = await StripStyleAttributes(sum.InnerText);

                if (!string.IsNullOrEmpty(entItem.Content))
                {
                    // Summary
                    entItem.Summary = await StripHtmlTags(entItem.Content);

                    //entItem.Summary = Truncate(entItem.Summary, 230);

                    //entItem.SummaryPlainText = Truncate(entItem.Summary, 78);

                    // gets image Uri
                    if (entItem.ImageUri == null)
                    {
                        entItem.ImageUri = await GetImageUriFromHtml(entItem.Content);
                    }
                }
            }

            entItem.Status = FeedEntryItem.ReadStatus.rsNew;
        }
Пример #4
0
        private async void FillEntryItemFromXmlRdf(FeedEntryItem entItem, XmlNode entryNode, XmlNamespaceManager NsMgr)
        {
            XmlNode entryTitle = entryNode.SelectSingleNode("rss:title", NsMgr);

            entItem.Name = (entryTitle != null) ? entryTitle.InnerText : "";

            XmlNode entryLinkUri = entryNode.SelectSingleNode("rss:link", NsMgr);

            try
            {
                if (entryLinkUri != null)
                {
                    if (!string.IsNullOrEmpty(entryLinkUri.InnerText))
                    {
                        entItem.AltHtmlUri = new Uri(entryLinkUri.InnerText);
                    }
                }
            }
            catch (Exception e)
            {
                Debug.WriteLine("Exception @new Uri(entryLinkUri.InnerText)" + "(" + entItem.Name + ")" + " : " + e.Message);

                ToDebugWindow(">> Exception @RssFeedClient@FillEntryItemFromXmlRdf:new Uri()"
                              + Environment.NewLine +
                              "RSS feed entry (" + entItem.Name + ") contain invalid entry Uri: " + e.Message +
                              Environment.NewLine);
            }

            if (string.IsNullOrEmpty(entItem.EntryId))
            {
                if (entItem.AltHtmlUri != null)
                {
                    entItem.EntryId = entItem.AltHtmlUri.AbsoluteUri;
                }
            }

            XmlNode entryPudDate = entryNode.SelectSingleNode("dc:date", NsMgr);

            if (entryPudDate != null)
            {
                string s = entryPudDate.InnerText;
                if (!string.IsNullOrEmpty(s))
                {
                    try
                    {
                        entItem.Published = DateTime.Parse(s, null, System.Globalization.DateTimeStyles.RoundtripKind);
                    }
                    catch (Exception e)
                    {
                        //Debug.WriteLine("Exception @DateTime.Parse in the RSS 1.0 feed " + "(" + entItem.Name + ")" + " : " + e.Message);

                        ToDebugWindow(">> Exception @FeedClient@FillEntryItemFromXmlRdf: DateTime.Parse()"
                                      + Environment.NewLine +
                                      "RSS feed entry(" + entItem.Name + ") contain invalid entry dc:date: " + e.Message +
                                      Environment.NewLine);
                    }
                }
            }

            string      entryAuthor  = "";
            XmlNodeList entryAuthors = entryNode.SelectNodes("dc:creator", NsMgr);

            if (entryAuthors != null)
            {
                foreach (XmlNode auth in entryAuthors)
                {
                    if (string.IsNullOrEmpty(entryAuthor))
                    {
                        entryAuthor = auth.InnerText;
                    }
                    else
                    {
                        entryAuthor += "/" + auth.InnerText;
                    }
                }
            }

            if (string.IsNullOrEmpty(entryAuthor))
            {
                if (entItem.AltHtmlUri != null)
                {
                    entryAuthor = entItem.AltHtmlUri.Host;
                }
            }

            entItem.Author = entryAuthor;

            // Force textHtml for RSS feed. Even though description was missing. (needs this for browser)
            entItem.ContentType = EntryItem.ContentTypes.textHtml;

            XmlNode sum = entryNode.SelectSingleNode("rss:description", NsMgr);

            if (sum != null)
            {
                // Content
                entItem.Content = await StripStyleAttributes(sum.InnerText);

                if (!string.IsNullOrEmpty(entItem.Content))
                {
                    // Summary
                    entItem.Summary = await StripHtmlTags(entItem.Content);

                    //entItem.SummaryPlainText = Truncate(entItem.SummaryPlainText, 78);
                }

                // gets image Uri
                entItem.ImageUri = await GetImageUriFromHtml(entItem.Content);
            }

            entItem.Status = FeedEntryItem.ReadStatus.rsNew;
        }
Пример #5
0
        public override async Task <HttpClientEntryItemCollectionResultWrapper> GetEntries(Uri entriesUrl, string feedId)
        {
            HttpClientEntryItemCollectionResultWrapper res = new HttpClientEntryItemCollectionResultWrapper();

            List <EntryItem> list = new List <EntryItem>();

            res.Entries = list;

            if (!(entriesUrl.Scheme.Equals("http") || entriesUrl.Scheme.Equals("https")))
            {
                ToDebugWindow("<< Invalid URI scheme:"
                              + Environment.NewLine
                              + entriesUrl.Scheme
                              + Environment.NewLine);

                InvalidUriScheme(res.Error, entriesUrl.Scheme, "FeedClient: GetEntries");
                res.IsError = true;

                return(res);
            }

            try
            {
                var HTTPResponseMessage = await _HTTPConn.Client.GetAsync(entriesUrl);

                if (HTTPResponseMessage.IsSuccessStatusCode)
                {
                    //string s = await HTTPResponseMessage.Content.ReadAsStringAsync();

                    /*
                     * ToDebugWindow(">> HTTP Request: GET "
                     + entriesUrl.AbsoluteUri
                     + Environment.NewLine
                     + "<< HTTP Response " + HTTPResponseMessage.StatusCode.ToString()
                     +  //+ Environment.NewLine + s + Environment.NewLine);
                     + Environment.NewLine);
                     */

                    var source = await HTTPResponseMessage.Content.ReadAsStreamAsync();

                    // Load XML
                    XmlDocument xdoc = new XmlDocument();
                    try
                    {
                        XmlReader reader = XmlReader.Create(source);
                        xdoc.Load(reader);
                    }
                    catch (Exception e)
                    {
                        ToDebugWindow("<< Invalid XML document returned: " + entriesUrl.AbsoluteUri
                                      + Environment.NewLine
                                      + e.Message
                                      + Environment.NewLine);;

                        InvalidXml(res.Error, e.Message, "FeedClient: GetEntries");
                        res.IsError = true;

                        return(res);
                    }

                    // RSS 2.0
                    if (xdoc.DocumentElement.LocalName.Equals("rss"))
                    {
                        XmlNamespaceManager NsMgr = new XmlNamespaceManager(xdoc.NameTable);
                        NsMgr.AddNamespace("dc", "http://purl.org/dc/elements/1.1/");

                        XmlNodeList entryList;
                        entryList = xdoc.SelectNodes("//rss/channel/item");
                        if (entryList == null)
                        {
                            res.Entries = list;

                            return(res);
                        }

                        foreach (XmlNode l in entryList)
                        {
                            FeedEntryItem ent = new FeedEntryItem("", feedId, this);

                            FillEntryItemFromXmlRss(ent, l, NsMgr);

                            if (!string.IsNullOrEmpty(ent.EntryId))
                            {
                                list.Add(ent);
                            }
                        }

                        //
                        //await GetImages(list);
                    }
                    // RSS 1.0
                    else if (xdoc.DocumentElement.LocalName.Equals("RDF"))
                    {
                        XmlNamespaceManager NsMgr = new XmlNamespaceManager(xdoc.NameTable);
                        NsMgr.AddNamespace("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
                        NsMgr.AddNamespace("rss", "http://purl.org/rss/1.0/");
                        NsMgr.AddNamespace("dc", "http://purl.org/dc/elements/1.1/");

                        XmlNodeList entryList = xdoc.SelectNodes("//rdf:RDF/rss:item", NsMgr);
                        if (entryList == null)
                        {
                            res.Entries = list;

                            return(res);
                        }

                        foreach (XmlNode l in entryList)
                        {
                            FeedEntryItem ent = new FeedEntryItem("", feedId, this);

                            FillEntryItemFromXmlRdf(ent, l, NsMgr);

                            if (!string.IsNullOrEmpty(ent.EntryId))
                            {
                                list.Add(ent);
                            }
                        }

                        //
                        //await GetImages(list);
                    }
                    else if (xdoc.DocumentElement.LocalName.Equals("feed"))
                    {
                        if (xdoc.DocumentElement.NamespaceURI.Equals("http://www.w3.org/2005/Atom"))
                        {
                            XmlNamespaceManager atomNsMgr = new XmlNamespaceManager(xdoc.NameTable);
                            atomNsMgr.AddNamespace("atom", "http://www.w3.org/2005/Atom");
                            atomNsMgr.AddNamespace("app", "http://www.w3.org/2007/app");

                            XmlNodeList entryList;
                            entryList = xdoc.SelectNodes("//atom:feed/atom:entry", atomNsMgr);
                            if (entryList == null)
                            {
                                res.Entries = list;

                                return(res);
                            }

                            foreach (XmlNode l in entryList)
                            {
                                FeedEntryItem ent = new FeedEntryItem("", feedId, this);
                                //ent.Status = EditEntryItem.EditStatus.esNormal;

                                FillEntryItemFromXmlAtom10(ent, l, atomNsMgr, feedId);

                                if (!string.IsNullOrEmpty(ent.EntryId))
                                {
                                    list.Add(ent);
                                }
                            }

                            //
                            //await GetImages(list);
                        }
                        // Old Atom 0.3
                        else if (xdoc.DocumentElement.NamespaceURI.Equals("http://purl.org/atom/ns#"))
                        {
                            XmlNamespaceManager atomNsMgr = new XmlNamespaceManager(xdoc.NameTable);
                            atomNsMgr.AddNamespace("atom", "http://purl.org/atom/ns#");
                            atomNsMgr.AddNamespace("dc", "http://purl.org/dc/elements/1.1/");

                            XmlNodeList entryList;
                            entryList = xdoc.SelectNodes("//atom:feed/atom:entry", atomNsMgr);
                            if (entryList == null)
                            {
                                res.Entries = list;

                                return(res);
                            }

                            foreach (XmlNode l in entryList)
                            {
                                FeedEntryItem ent = new FeedEntryItem("", feedId, this);
                                //ent.Status = EditEntryItem.EditStatus.esNormal;

                                FillEntryItemFromXmlAtom03(ent, l, atomNsMgr);

                                if (!string.IsNullOrEmpty(ent.EntryId))
                                {
                                    list.Add(ent);
                                }
                            }

                            //
                            //await GetImages(list);

                            ToDebugWindow("<< Old version of Atom feed format detected. Update recommended: " + entriesUrl.AbsoluteUri
                                          + Environment.NewLine);
                        }
                        else
                        {
                            ToDebugWindow("<< FormatUndetermined @FeedClient:[email protected]"
                                          + Environment.NewLine);

                            FormatUndetermined(res.Error, "FeedClient:GetEntries");
                            res.IsError = true;

                            return(res);
                        }
                    }
                    else
                    {
                        ToDebugWindow("<< FormatUndetermined @FeedClient:GetEntries:xdoc.DocumentElement.LocalName/NamespaceURI"
                                      + Environment.NewLine);

                        FormatUndetermined(res.Error, "FeedClient:GetEntries");
                        res.IsError = true;

                        return(res);
                    }
                }
                // HTTP non 200 status code.
                else
                {
                    var contents = await HTTPResponseMessage.Content.ReadAsStringAsync();

                    if (contents != null)
                    {
                        ToDebugWindow(">> HTTP Request: GET "
                                      + entriesUrl.AbsoluteUri
                                      + Environment.NewLine
                                      + "<< HTTP Response " + HTTPResponseMessage.StatusCode.ToString()
                                      + Environment.NewLine
                                      + contents + Environment.NewLine);
                    }

                    NonSuccessStatusCode(res.Error, HTTPResponseMessage.StatusCode.ToString(), "_HTTPConn.Client.GetAsync", "FeedClient:GetEntries");
                    res.IsError = true;

                    return(res);
                }
            }
            // Internet connection errors
            catch (System.Net.Http.HttpRequestException e)
            {
                Debug.WriteLine("<< HttpRequestException: " + e.Message);

                ToDebugWindow(" << HttpRequestException: "
                              + Environment.NewLine
                              + e.Message
                              + Environment.NewLine);

                HttpReqException(res.Error, e.Message, "_HTTPConn.Client.GetAsync", "FeedClient:GetEntries");
                res.IsError = true;

                return(res);
            }
            catch (Exception e)
            {
                Debug.WriteLine("HTTP error: " + e.Message);

                ToDebugWindow("<< HTTP error:"
                              + Environment.NewLine
                              + e.Message
                              + Environment.NewLine);

                GenericException(res.Error, "", ErrorObject.ErrTypes.HTTP, "HTTP request error (Exception)", e.Message, "_HTTPConn.Client.GetAsync", "FeedClient:GetEntries");
                res.IsError = true;

                return(res);
            }

            return(res);
        }