Beispiel #1
0
        /// <summary>
        /// Download the preferred language of the user
        /// </summary>
        /// <param name="_userId"></param>
        /// <returns></returns>
        internal TvdbLanguage DownloadUserPreferredLanguage(String _userId)
        {
            String xml;

            try
            {
                xml = m_webClient.DownloadString(TvdbLinks.CreateUserLanguageLink(_userId));
            }
            catch (WebException ex)
            {
                Log.Warn("Request not successfull", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve preferred languae for user " + _userId +
                                                         ", it seems like you use an invalid api key (" + m_apiKey + ")");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve preferred languae for user " + _userId +
                                                        ", check your internet connection and the status of http://thetvdb.com");
                }
            }
            List <TvdbLanguage> langList = m_xmlHandler.ExtractLanguages(xml);

            if (langList != null && langList.Count == 1)
            {
                return(langList[0]);
            }
            return(null);
        }
Beispiel #2
0
        /// <summary>
        /// Download the episodes
        /// </summary>
        /// <param name="_seriesId"></param>
        /// <param name="_language"></param>
        /// <returns></returns>
        internal List <TvdbEpisode> DownloadEpisodes(int _seriesId, TvdbLanguage _language)
        {
            String xml;

            try
            {
                xml = m_webClient.DownloadString(TvdbLinks.CreateSeriesEpisodesLink(m_apiKey, _seriesId, _language));
            }
            catch (WebException ex)
            {
                Log.Warn("Request not successfull", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve episodes fo " + _seriesId +
                                                         ", it seems like you have an invalid api key (" + m_apiKey + ")");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve episodes for" + _seriesId +
                                                        ", check your internet connection and the status of http://thetvdb.com");
                }
            }
            List <TvdbEpisode> epList = m_xmlHandler.ExtractEpisodes(xml);

            return(epList);
        }
Beispiel #3
0
        /// <summary>
        /// Download the episodes
        /// </summary>
        /// <param name="_seriesId"></param>
        /// <param name="_language"></param>
        /// <returns></returns>
        internal List <TvdbEpisode> DownloadEpisodes(int _seriesId, TvdbLanguage _language)
        {
            String             xml    = m_webClient.DownloadString(TvdbLinks.CreateSeriesEpisodesLink(m_apiKey, _seriesId, _language));
            List <TvdbEpisode> epList = m_xmlHandler.ExtractEpisodes(xml);

            return(epList);
        }
        /// <summary>
        /// Load the thumb from tvdb
        /// </summary>
        /// <returns></returns>
        public bool LoadThumb(bool _replaceOld)
        {
            bool wasLoaded = m_thumbLoaded;//is the banner already loaded at this point

            lock (m_thumbLoadingLock)
            {//if another thread is already loading THIS banner, the lock will block this thread until the other thread
                //has finished loading
                if (!wasLoaded && !_replaceOld && m_thumbLoaded)
                {////the banner has already been loaded from a different thread and we don't want to replace it
                    return(false);
                }
                m_thumbLoading = true;
                try
                {
                    Image img = LoadImage(TvdbLinks.CreateBannerLink(m_thumbPath));

                    if (img != null)
                    {
                        m_bannerThumb  = img;
                        m_thumbLoaded  = true;
                        m_thumbLoading = false;
                        return(true);
                    }
                }
                catch (WebException ex)
                {
                    Log.Error("Couldn't load banner thumb" + m_thumbPath, ex);
                }
                m_thumbLoaded  = false;
                m_thumbLoading = false;
                return(false);
            }
        }
        /// <summary>
        /// Download the user favorite list
        /// </summary>
        /// <param name="_userId"></param>
        /// <param name="_type"></param>
        /// <param name="_seriesId"></param>
        /// <returns></returns>
        internal List <int> DownloadUserFavoriteList(String _userId, Util.UserFavouriteAction _type, int _seriesId)
        {
            String xml  = "";
            String link = "";

            try
            {
                link = TvdbLinks.CreateUserFavouriteLink(_userId, _type, _seriesId);
                xml  = m_webClient.DownloadString(link);
            }
            catch (XmlException ex)
            {
                Log.Error("Error parsing the xml file " + link + "\n\n" + xml, ex);
                throw new TvdbInvalidXmlException("Error parsing the xml file " + link + "\n\n" + xml);
            }
            catch (WebException ex)
            {
                Log.Warn("Request not successfull", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve favorite list for user " + _userId +
                                                         ", it seems like you use an invalid api key");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve favorite list for user " + _userId +
                                                        ", check your internet connection and the status of http://thetvdb.com");
                }
            }
            List <int> favList = m_xmlHandler.ExtractSeriesFavorites(xml);

            return(favList);
        }
Beispiel #6
0
        /// <summary>
        /// Download the banners
        /// </summary>
        /// <param name="_seriesId"></param>
        /// <returns></returns>
        internal List <TvdbBanner> DownloadBanners(int _seriesId)
        {
            String            xml     = m_webClient.DownloadString(TvdbLinks.CreateSeriesBannersLink(m_apiKey, _seriesId));
            List <TvdbBanner> banners = m_xmlHandler.ExtractBanners(xml);

            return(banners);
        }
        /// <summary>
        /// Make the request for rating an episode
        /// </summary>
        /// <param name="_userId"></param>
        /// <param name="_episodeId"></param>
        /// <param name="_rating"></param>
        /// <returns></returns>
        internal double RateEpisode(String _userId, int _episodeId, int _rating)
        {
            String xml  = "";
            String link = "";

            try
            {
                link = TvdbLinks.CreateUserEpisodeRating(_userId, _episodeId, _rating);
                xml  = m_webClient.DownloadString(link);
                return(m_xmlHandler.ExtractRating(xml));
            }
            catch (XmlException ex)
            {
                Log.Error("Error parsing the xml file " + link + "\n\n" + xml, ex);
                throw new TvdbInvalidXmlException("Error parsing the xml file " + link + "\n\n" + xml);
            }
            catch (WebException ex)
            {
                Log.Warn("Request not successfull", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to rate episode " + _episodeId +
                                                         ", it seems like you use an invalid api key");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to rate episode " + _episodeId +
                                                        ", check your internet connection and the status of http://thetvdb.com");
                }
            }
        }
Beispiel #8
0
        /// <summary>
        /// Download available languages
        /// </summary>
        /// <returns></returns>
        internal List <TvdbLanguage> DownloadLanguages()
        {
            TvdbXmlReader hand = new TvdbXmlReader();
            String        xml  = m_webClient.DownloadString(TvdbLinks.CreateLanguageLink(m_apiKey));

            return(hand.ExtractLanguages(xml));
        }
        /// <summary>
        /// Download the banners
        /// </summary>
        /// <param name="_seriesId"></param>
        /// <returns></returns>
        internal List <TvdbBanner> DownloadBanners(int _seriesId)
        {
            String xml  = "";
            String link = "";

            try
            {
                link = TvdbLinks.CreateSeriesBannersLink(m_apiKey, _seriesId);
                xml  = m_webClient.DownloadString(link);
                List <TvdbBanner> banners = m_xmlHandler.ExtractBanners(xml);
                return(banners);
            }
            catch (XmlException ex)
            {
                Log.Error("Error parsing the xml file " + link + "\n\n" + xml, ex);
                throw new TvdbInvalidXmlException("Error parsing the xml file " + link + "\n\n" + xml);
            }
            catch (WebException ex)
            {
                Log.Warn("Request not successfull", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve banners fo " + _seriesId +
                                                         ", it seems like you have an invalid api key");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve banners for" + _seriesId +
                                                        ", check your internet connection and the status of http://thetvdb.com");
                }
            }
        }
Beispiel #10
0
        /// <summary>
        /// Download the user favorite list
        /// </summary>
        /// <param name="_userId"></param>
        /// <param name="_type"></param>
        /// <param name="_seriesId"></param>
        /// <returns></returns>
        internal List <int> DownloadUserFavoriteList(String _userId, Util.UserFavouriteAction _type, int _seriesId)
        {
            String     xml     = m_webClient.DownloadString(TvdbLinks.CreateUserFavouriteLink(_userId, _type, _seriesId));
            List <int> favList = m_xmlHandler.ExtractSeriesFavorites(xml);

            return(favList);
        }
Beispiel #11
0
        internal List <TvdbMirror> DownloadMirrorList()
        {
            String xml  = "";
            String link = "";

            try
            {
                link = TvdbLinks.CreateMirrorsLink(m_apiKey);
                xml  = m_webClient.DownloadString(link);
                List <TvdbMirror> list = m_xmlHandler.ExtractMirrors(xml);
                return(list);
            }
            catch (XmlException ex)
            {
                Log.Error("Error parsing the xml file " + link + "\n\n" + xml, ex);
                throw new TvdbInvalidXmlException("Error parsing the xml file " + link + "\n\n" + xml);
            }
            catch (WebException ex)
            {
                Log.Warn("Couldn't download mirror list from thetvdb.com", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve mirror list" +
                                                         ", it seems like you use an invalid api key");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve mirror list" +
                                                        ", check your internet connection and the status of http://thetvdb.com");
                }
            }
        }
Beispiel #12
0
        internal TvdbSeriesFields DownloadSeriesFields(int _seriesId, TvdbLanguage _language)
        {
            String data;

            try
            {
                data = m_webClient.DownloadString(TvdbLinks.CreateSeriesLink(m_apiKey, _seriesId, _language, false, false));
            }
            catch (Exception ex)
            {
                Log.Warn("Request not successfull", ex);
                return(null);
            }
            //extract all series the xml file contains
            List <TvdbSeriesFields> seriesList = m_xmlHandler.ExtractSeriesFields(data);

            if (seriesList != null && seriesList.Count == 1)
            {
                return(seriesList[0]);
            }
            else
            {
                return(null);
            }
        }
Beispiel #13
0
        /// <summary>
        /// Gets all series this user has already ratet
        /// </summary>
        /// <exception cref="TvdbUserNotFoundException">Thrown when no user is set</exception>
        /// <returns></returns>
        internal Dictionary <int, TvdbRating> DownloadAllSeriesRatings(String _userId)
        {
            String xml  = "";
            String link = "";

            try
            {
                link = TvdbLinks.CreateAllSeriesRatingsLink(m_apiKey, _userId);
                xml  = m_webClient.DownloadString(link);
                return(m_xmlHandler.ExtractRatings(xml, TvdbRating.ItemType.Series));
            }
            catch (XmlException ex)
            {
                Log.Error("Error parsing the xml file " + link + "\n\n" + xml, ex);
                throw new TvdbInvalidXmlException("Error parsing the xml file " + link + "\n\n" + xml);
            }
            catch (WebException ex)
            {
                Log.Warn("Request not successfull", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve rating of all series " +
                                                         ", it seems like you use an invalid api key");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve rating of all series " +
                                                        ", check your internet connection and the status of http://thetvdb.com");
                }
            }
        }
Beispiel #14
0
 /// <summary>
 /// Download the episode specified from http://thetvdb.com
 /// </summary>
 /// <param name="_seriesId">series id</param>
 /// <param name="_seasonNr">season nr</param>
 /// <param name="_episodeNr">episode nr</param>
 /// <param name="_language">language</param>
 /// <param name="_order">order</param>
 /// <returns></returns>
 internal TvdbEpisode DownloadEpisode(int _seriesId, int _seasonNr, int _episodeNr, String _order, TvdbLanguage _language)
 {
     try
     {
         String             xml    = m_webClient.DownloadString(TvdbLinks.CreateEpisodeLink(m_apiKey, _seriesId, _seasonNr, _episodeNr, _order, _language));
         List <TvdbEpisode> epList = m_xmlHandler.ExtractEpisodes(xml);
         if (epList.Count == 1)
         {
             return(epList[0]);
         }
         else
         {
             return(null);
         }
     }
     catch (WebException ex)
     {
         Log.Warn("Request not successfull", ex);
         if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
         {
             throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve " + _seriesId + "/" +
                                                  _order + "/" + _seasonNr + "/" + _episodeNr + "/" + _language.Abbriviation +
                                                  ", it seems like you have an invalid api key (" + m_apiKey + ")");
         }
         else
         {
             throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve " + _seriesId + "/" +
                                                 _order + "/" + _seasonNr + "/" + _episodeNr + "/" + _language.Abbriviation +
                                                 ", check your internet connection and the status of http://thetvdb.com");
         }
     }
 }
Beispiel #15
0
        internal TvdbSeriesFields DownloadSeriesFields(int _seriesId, TvdbLanguage _language)
        {
            String data;

            try
            {
                data = m_webClient.DownloadString(TvdbLinks.CreateSeriesLink(m_apiKey, _seriesId, _language, false, false));
            }
            catch (WebException ex)
            {
                Log.Warn("Request not successfull", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve " + _seriesId +
                                                         ", it seems like you have an invalid api key (" + m_apiKey + ")");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve " + _seriesId +
                                                        ", check your internet connection and the status of http://thetvdb.com");
                }
            }
            //extract all series the xml file contains
            List <TvdbSeriesFields> seriesList = m_xmlHandler.ExtractSeriesFields(data);

            if (seriesList != null && seriesList.Count == 1)
            {
                return(seriesList[0]);
            }
            else
            {
                return(null);
            }
        }
Beispiel #16
0
        /// <summary>
        /// Download series from tvdb
        /// </summary>
        /// <param name="series"></param>
        /// <returns></returns>
        internal TvdbSeries DownloadSeries(int _seriesId, TvdbLanguage _language, bool _loadEpisodes, bool _loadActors, bool _loadBanners)
        {
            //download the xml data from this request
            String data;

            try
            {
                data = m_webClient.DownloadString(TvdbLinks.CreateSeriesLink(m_apiKey, _seriesId, _language, _loadEpisodes, false));
            }
            catch (Exception ex)
            {
                Log.Warn("Request not successfull", ex);
                return(null);
            }
            //extract all series the xml file contains
            List <TvdbSeries> seriesList = m_xmlHandler.ExtractSeries(data);

            //if a request is made on a series id, one and only one result
            //should be returned, otherwise there obviously was an error
            if (seriesList != null && seriesList.Count == 1)
            {
                TvdbSeries series = seriesList[0];
                if (_loadEpisodes)
                {
                    //add episode info to series
                    List <TvdbEpisode> epList = m_xmlHandler.ExtractEpisodes(data);
                    foreach (TvdbEpisode e in epList)
                    {
                        Util.AddEpisodeToSeries(e, series);
                    }
                }

                //also load actors
                if (_loadActors)
                {
                    List <TvdbActor> list = DownloadActors(_seriesId);
                    if (list != null)
                    {
                        series.TvdbActors = list;
                    }
                }

                //also load banner paths
                if (_loadBanners)
                {
                    List <TvdbBanner> banners = DownloadBanners(_seriesId);
                    if (banners != null)
                    {
                        series.Banners = banners;
                    }
                }
                return(series);
            }
            else
            {
                Log.Warn("More than one series returned when trying to retrieve series " + _seriesId);
                return(null);
            }
        }
Beispiel #17
0
        /// <summary>
        /// Download an Update
        /// </summary>
        /// <param name="updateSeries"></param>
        /// <param name="updateEpisodes"></param>
        /// <param name="_interval"></param>
        /// <returns></returns>
        internal DateTime DownloadUpdate(out List <TvdbSeries> updateSeries, out List <TvdbEpisode> updateEpisodes, Util.UpdateInterval _interval)
        {
            String xml = m_webClient.DownloadString(TvdbLinks.CreateUpdateLink(m_apiKey, Util.UpdateInterval.day));

            updateEpisodes = m_xmlHandler.ExtractEpisodeUpdates(xml);
            updateSeries   = m_xmlHandler.ExtractSeriesUpdates(xml);

            return(m_xmlHandler.ExtractUpdateTime(xml));
        }
Beispiel #18
0
        /// <summary>
        /// Download the preferred language of the user
        /// </summary>
        /// <param name="_userId"></param>
        /// <returns></returns>
        internal TvdbLanguage DownloadUserPreferredLanguage(String _userId)
        {
            String xml = m_webClient.DownloadString(TvdbLinks.CreateUserLanguageLink(_userId));
            List <TvdbLanguage> langList = m_xmlHandler.ExtractLanguages(xml);

            if (langList != null && langList.Count == 1)
            {
                return(langList[0]);
            }
            return(null);
        }
Beispiel #19
0
        /// <summary>
        /// Download an Update
        /// </summary>
        /// <param name="_updateSeries">updated series to return</param>
        /// <param name="_updateEpisodes">updated episodes to return</param>
        /// <param name="_updateBanners">updated banners to return</param>
        /// <param name="_interval">interval to download</param>
        /// <param name="_zipped">use zip</param>
        /// <returns>Time of the update</returns>
        internal DateTime DownloadUpdate(out List <TvdbSeries> _updateSeries, out List <TvdbEpisode> _updateEpisodes,
                                         out List <TvdbBanner> _updateBanners, Util.UpdateInterval _interval, bool _zipped)
        {
            String xml  = "";
            String link = "";

            try
            {
                link = TvdbLinks.CreateUpdateLink(m_apiKey, _interval, _zipped);
                if (_zipped)
                {
                    byte[]         data = m_webClient.DownloadData(link);
                    ZipInputStream zip  = new ZipInputStream(new MemoryStream(data));
                    zip.GetNextEntry();
                    byte[] buffer = new byte[zip.Length];
                    int    count  = zip.Read(buffer, 0, (int)zip.Length);
                    xml = Encoding.UTF8.GetString(buffer);
                }
                else
                {
                    xml = m_webClient.DownloadString(link);
                }

                _updateEpisodes = m_xmlHandler.ExtractEpisodeUpdates(xml);
                _updateSeries   = m_xmlHandler.ExtractSeriesUpdates(xml);
                _updateBanners  = m_xmlHandler.ExtractBannerUpdates(xml);

                return(m_xmlHandler.ExtractUpdateTime(xml));
            }
            catch (XmlException ex)
            {
                Log.Error("Error parsing the xml file " + link + "\n\n" + xml, ex);
                throw new TvdbInvalidXmlException("Error parsing the xml file " + link + "\n\n" + xml);
            }
            catch (ZipException ex)
            {
                Log.Error("Error unzipping the xml file " + link, ex);
                throw new TvdbInvalidXmlException("Error unzipping the xml file " + link);
            }
            catch (WebException ex)
            {
                Log.Warn("Request not successfull", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve updates for " + _interval +
                                                         ", it seems like you use an invalid api key");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve updates for " + _interval +
                                                        ", check your internet connection and the status of http://thetvdb.com");
                }
            }
        }
Beispiel #20
0
        /// <summary>
        /// Download the episode specified from http://thetvdb.com
        /// </summary>
        /// <param name="_seriesId">series id</param>
        /// <param name="_airDate">when did the episode air</param>
        /// <param name="_language">language</param>
        /// <returns>Episode</returns>
        internal TvdbEpisode DownloadEpisode(int _seriesId, DateTime _airDate, TvdbLanguage _language)
        {
            String xml  = "";
            String link = "";

            try
            {
                link = TvdbLinks.CreateEpisodeLink(m_apiKey, _seriesId, _airDate, _language);
                xml  = m_webClient.DownloadString(link);
                if (!xml.Contains("No Results from SP"))
                {
                    List <TvdbEpisode> epList = m_xmlHandler.ExtractEpisodes(xml);
                    if (epList.Count == 1)
                    {
                        return(epList[0]);
                    }
                    else
                    {
                        return(null);
                    }
                }
                else
                {
                    return(null);
                }
            }
            catch (XmlException ex)
            {
                Log.Error("Error parsing the xml file " + link + "\n\n" + xml, ex);
                throw new TvdbInvalidXmlException("Error parsing the xml file " + link + "\n\n" + xml);
            }
            catch (WebException ex)
            {
                Log.Warn("Request not successfull", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbContentNotFoundException("Couldn't download episode  for series " + _seriesId + " from " +
                                                           _airDate.ToShortDateString() + "(" + _language.Abbriviation +
                                                           "), maybe the episode doesn't exist");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't download episode  for series " + _seriesId + " from " +
                                                        _airDate.ToShortDateString() + "(" + _language.Abbriviation +
                                                        "), maybe the episode doesn't exist");
                }
            }
        }
Beispiel #21
0
        internal Dictionary <int, TvdbRating> DownloadRatingsForSeries(string _userId, int _seriesId)
        {
            String xml  = "";
            String link = "";

            try
            {
                link = TvdbLinks.CreateSeriesRatingsLink(m_apiKey, _userId, _seriesId);
                xml  = m_webClient.DownloadString(link);
                Dictionary <int, TvdbRating> retList     = m_xmlHandler.ExtractRatings(xml, TvdbRating.ItemType.Series);
                Dictionary <int, TvdbRating> episodeList = m_xmlHandler.ExtractRatings(xml, TvdbRating.ItemType.Episode);
                if (retList != null && episodeList != null && retList.Count > 0)
                {
                    foreach (KeyValuePair <int, TvdbRating> r in episodeList)
                    {
                        if (!retList.ContainsKey(r.Key))
                        {
                            retList.Add(r.Key, r.Value);
                        }
                    }
                    return(retList);
                }
                else
                {
                    return(null);
                }
            }
            catch (XmlException ex)
            {
                Log.Error("Error parsing the xml file " + link + "\n\n" + xml, ex);
                throw new TvdbInvalidXmlException("Error parsing the xml file " + link + "\n\n" + xml);
            }
            catch (WebException ex)
            {
                Log.Warn("Request not successfull", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve rating of all series " +
                                                         ", it seems like you use an invalid api key");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve rating of all series " +
                                                        ", check your internet connection and the status of http://thetvdb.com");
                }
            }
        }
Beispiel #22
0
        /// <summary>
        /// Download the episode specified from http://thetvdb.com
        /// </summary>
        /// <param name="_seriesId">series id</param>
        /// <param name="_seasonNr">season nr</param>
        /// <param name="_episodeNr">episode nr</param>
        /// <param name="_language">language</param>
        /// <param name="_order">order</param>
        /// <returns></returns>
        internal TvdbEpisode DownloadEpisode(int _seriesId, int _seasonNr, int _episodeNr, String _order, TvdbLanguage _language)
        {
            String xml  = "";
            String link = "";

            try
            {
                link = TvdbLinks.CreateEpisodeLink(m_apiKey, _seriesId, _seasonNr, _episodeNr, _order, _language);
                xml  = m_webClient.DownloadString(link);
                List <TvdbEpisode> epList = m_xmlHandler.ExtractEpisodes(xml);
                if (epList.Count == 1)
                {
                    return(epList[0]);
                }
                else
                {
                    return(null);
                }
            }
            catch (XmlException ex)
            {
                Log.Error("Error parsing the xml file " + link + "\n\n" + xml, ex);
                throw new TvdbInvalidXmlException("Error parsing the xml file " + link + "\n\n" + xml);
            }
            catch (WebException ex)
            {
                Log.Warn("Request not successfull", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbContentNotFoundException("Couldn't download episode " + _seriesId + "/" +
                                                           _order + "/" + _seasonNr + "/" + _episodeNr + "/" + _language.Abbriviation +
                                                           ", maybe the episode doesn't exist");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve " + _seriesId + "/" +
                                                        _order + "/" + _seasonNr + "/" + _episodeNr + "/" + _language.Abbriviation +
                                                        ", check your internet connection and the status of http://thetvdb.com");
                }
            }
        }
Beispiel #23
0
 /// <summary>
 /// Download search results
 /// </summary>
 /// <param name="_name"></param>
 /// <returns></returns>
 internal List <TvdbSearchResult> DownloadSearchResults(String _name)
 {
     try
     {
         String xml = m_webClient.DownloadString(TvdbLinks.CreateSearchLink(_name));
         return(m_xmlHandler.ExtractSeriesSearchResults(xml));
     }
     catch (WebException ex)
     {
         Log.Warn("Request not successfull", ex);
         if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
         {
             throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve search results for " + _name +
                                                  ", it seems like you use an invalid api key (" + m_apiKey + ")");
         }
         else
         {
             throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve search results for " + _name +
                                                 ", check your internet connection and the status of http://thetvdb.com");
         }
     }
 }
Beispiel #24
0
 /// <summary>
 /// Download the list of actors
 /// </summary>
 /// <param name="_seriesId"></param>
 /// <returns></returns>
 internal List <TvdbActor> DownloadActors(int _seriesId)
 {
     try
     {
         String xml = m_webClient.DownloadString(TvdbLinks.CreateActorLink(_seriesId, m_apiKey));
         return(m_xmlHandler.ExtractActors(xml));
     }
     catch (WebException ex)
     {
         Log.Warn("Couldn't download actor info from thetvdb.com", ex);
         if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
         {
             throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve actor info of series " + _seriesId +
                                                  ", it seems like you use an invalid api key (" + m_apiKey + ")");
         }
         else
         {
             throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve actor info of series " + _seriesId +
                                                 ", check your internet connection and the status of http://thetvdb.com");
         }
     }
 }
Beispiel #25
0
 /// <summary>
 /// Download the episode rating without rating
 /// </summary>
 /// <param name="_userId">id of the user</param>
 /// <param name="_episodeId">id of the episode</param>
 /// <returns></returns>
 internal double DownloadEpisodeRating(String _userId, int _episodeId)
 {
     try
     {
         String xml = m_webClient.DownloadString(TvdbLinks.CreateUserEpisodeRating(_userId, _episodeId));
         return(m_xmlHandler.ExtractRating(xml));
     }
     catch (WebException ex)
     {
         Log.Warn("Request not successfull", ex);
         if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
         {
             throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve rating of series " + _episodeId +
                                                  ", it seems like you use an invalid api key (" + m_apiKey + ")");
         }
         else
         {
             throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve rating of series " + _episodeId +
                                                 ", check your internet connection and the status of http://thetvdb.com");
         }
     }
 }
Beispiel #26
0
        /// <summary>
        /// Download the given episode from tvdb
        /// </summary>
        /// <param name="_episodeId"></param>
        /// <param name="_language"></param>
        /// <returns></returns>
        internal TvdbEpisode DownloadEpisode(int _episodeId, TvdbLanguage _language)
        {
            String data;

            try
            {
                data = m_webClient.DownloadString(TvdbLinks.CreateEpisodeLink(m_apiKey, _episodeId, _language, false));
            }
            catch (Exception ex)
            {
                Log.Warn("Request not successfull", ex);
                return(null);
            }
            List <TvdbEpisode> epList = m_xmlHandler.ExtractEpisodes(data);

            if (epList.Count == 1)
            {
                return(epList[0]);
            }
            else
            {
                return(null);
            }
        }
Beispiel #27
0
        /// <summary>
        /// Download the episode rating without rating
        /// </summary>
        /// <param name="_userId"></param>
        /// <param name="_seriesId"></param>
        /// <returns></returns>
        internal double DownloadEpisodeRating(String _userId, int _seriesId)
        {
            String xml = m_webClient.DownloadString(TvdbLinks.CreateUserEpisodeRating(_userId, _seriesId));

            return(m_xmlHandler.ExtractRating(xml));
        }
Beispiel #28
0
        internal TvdbSeries DownloadSeriesZipped(int _seriesId, TvdbLanguage _language)
        {
            //download the xml data from this request
            byte[] xml  = null;
            String link = "";

            try
            {
                link = TvdbLinks.CreateSeriesLinkZipped(m_apiKey, _seriesId, _language);
                xml  = m_webClient.DownloadData(link);

                ZipInputStream zip = new ZipInputStream(new MemoryStream(xml));

                ZipEntry entry         = zip.GetNextEntry();
                String   seriesString  = null;
                String   actorsString  = null;
                String   bannersString = null;
                while (entry != null)
                {
                    Log.Debug("Extracting " + entry.Name);
                    byte[] buffer = new byte[zip.Length];
                    int    count  = zip.Read(buffer, 0, (int)zip.Length);
                    if (entry.Name.Equals(_language.Abbriviation + ".xml"))
                    {
                        seriesString = Encoding.UTF8.GetString(buffer);
                    }
                    else if (entry.Name.Equals("banners.xml"))
                    {
                        bannersString = Encoding.UTF8.GetString(buffer);
                    }
                    else if (entry.Name.Equals("actors.xml"))
                    {
                        actorsString = Encoding.UTF8.GetString(buffer);
                    }
                    entry = zip.GetNextEntry();
                }
                zip.Close();

                //extract all series the xml file contains
                List <TvdbSeries> seriesList = m_xmlHandler.ExtractSeries(seriesString);

                //if a request is made on a series id, one and only one result
                //should be returned, otherwise there obviously was an error
                if (seriesList != null && seriesList.Count == 1)
                {
                    TvdbSeries series = seriesList[0];
                    series.EpisodesLoaded = true;
                    series.Episodes       = new List <TvdbEpisode>();
                    //add episode info to series
                    List <TvdbEpisode> epList = m_xmlHandler.ExtractEpisodes(seriesString);
                    foreach (TvdbEpisode e in epList)
                    {
                        Util.AddEpisodeToSeries(e, series);
                    }

                    //also load actors
                    List <TvdbActor> actors = m_xmlHandler.ExtractActors(actorsString);
                    if (actors != null)
                    {
                        series.TvdbActorsLoaded = true;
                        series.TvdbActors       = actors;
                    }

                    //also load banner paths
                    List <TvdbBanner> banners = m_xmlHandler.ExtractBanners(bannersString);
                    if (banners != null)
                    {
                        series.BannersLoaded = true;
                        series.Banners       = banners;
                    }

                    return(series);
                }
                else
                {
                    Log.Warn("More than one series returned when trying to retrieve series " + _seriesId);
                    return(null);
                }
            }
            catch (XmlException ex)
            {
                Log.Error("Error parsing the xml file " + link + "\n\n" + Encoding.Unicode.GetString(xml), ex);
                throw new TvdbInvalidXmlException("Error parsing the xml file " + link + "\n\n" + xml);
            }
            catch (WebException ex)
            {
                Log.Warn("Request not successfull", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve " + _seriesId +
                                                         ", it seems like you have an invalid api key");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve " + _seriesId +
                                                        ", check your internet connection and the status of http://thetvdb.com");
                }
            }
        }
Beispiel #29
0
        /// <summary>
        /// Download series from tvdb
        /// </summary>
        /// <param name="_seriesId">id of series</param>
        /// <param name="_language">language of series</param>
        /// <param name="_loadEpisodes">load episodes</param>
        /// <param name="_loadActors">load actors</param>
        /// <param name="_loadBanners">load banners</param>
        /// <returns></returns>
        internal TvdbSeries DownloadSeries(int _seriesId, TvdbLanguage _language, bool _loadEpisodes, bool _loadActors, bool _loadBanners)
        {
            //download the xml data from this request
            String xml  = "";
            String link = "";

            try
            {
                link = TvdbLinks.CreateSeriesLink(m_apiKey, _seriesId, _language, _loadEpisodes, false);
                xml  = m_webClient.DownloadString(link);

                //extract all series the xml file contains
                List <TvdbSeries> seriesList = m_xmlHandler.ExtractSeries(xml);

                //if a request is made on a series id, one and only one result
                //should be returned, otherwise there obviously was an error
                if (seriesList != null && seriesList.Count == 1)
                {
                    TvdbSeries series = seriesList[0];
                    if (_loadEpisodes)
                    {
                        //add episode info to series
                        List <TvdbEpisode> epList = m_xmlHandler.ExtractEpisodes(xml);
                        foreach (TvdbEpisode e in epList)
                        {
                            Util.AddEpisodeToSeries(e, series);
                        }
                    }

                    //also load actors
                    if (_loadActors)
                    {
                        List <TvdbActor> list = DownloadActors(_seriesId);
                        if (list != null)
                        {
                            series.TvdbActors = list;
                        }
                    }

                    //also load banner paths
                    if (_loadBanners)
                    {
                        List <TvdbBanner> banners = DownloadBanners(_seriesId);
                        if (banners != null)
                        {
                            series.Banners = banners;
                        }
                    }
                    return(series);
                }
                else
                {
                    Log.Warn("More than one series returned when trying to retrieve series " + _seriesId);
                    return(null);
                }
            }
            catch (XmlException ex)
            {
                Log.Error("Error parsing the xml file " + link + "\n\n" + xml, ex);
                throw new TvdbInvalidXmlException("Error parsing the xml file " + link + "\n\n" + xml);
            }
            catch (WebException ex)
            {
                Log.Warn("Request not successfull", ex);
                if (ex.Message.Equals("The remote server returned an error: (404) Not Found."))
                {
                    throw new TvdbInvalidApiKeyException("Couldn't connect to Thetvdb.com to retrieve " + _seriesId +
                                                         ", it seems like you have an invalid api key");
                }
                else
                {
                    throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve " + _seriesId +
                                                        ", check your internet connection and the status of http://thetvdb.com");
                }
            }
        }
Beispiel #30
0
        /// <summary>
        /// Download the list of actors
        /// </summary>
        /// <param name="_seriesId"></param>
        /// <returns></returns>
        internal List <TvdbActor> DownloadActors(int _seriesId)
        {
            String xml = m_webClient.DownloadString(TvdbLinks.CreateActorLink(_seriesId, m_apiKey));

            return(m_xmlHandler.ExtractActors(xml));
        }