/// <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> /// 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 (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 episode " + _episodeId + ", it seems like you have an invalid api key (" + m_apiKey + ")"); } else { throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve " + _episodeId + ", check your internet connection and the status of http://thetvdb.com"); } } List <TvdbEpisode> epList = m_xmlHandler.ExtractEpisodes(data); if (epList.Count == 1) { return(epList[0]); } else { return(null); } }
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); } }
/// <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 = ""; String link = ""; try { link = TvdbLinks.CreateSeriesEpisodesLink(m_apiKey, _seriesId, _language); xml = m_webClient.DownloadString(link); List <TvdbEpisode> epList = m_xmlHandler.ExtractEpisodes(xml); return(epList); } 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 episodes fo " + _seriesId + ", it seems like you have an invalid api key"); } 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"); } } }
/// <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); } }
/// <summary> /// Initialise the form /// </summary> /// <param name="_userId"></param> public void InitialiseForm(String _userId, ICacheProvider _provider) { //m_tvdbHandler = new Tvdb(new BinaryCacheProvider(@"cachefile.bin"), Resources.API_KEY);new XmlCacheProvider("XmlCache") m_tvdbHandler = new Tvdb(_provider, Resources.API_KEY); m_tvdbHandler.InitCache(); List<TvdbLanguage> m_languages = m_tvdbHandler.Languages; foreach (TvdbLanguage l in m_languages) { if (l.Abbriviation.Equals("en")) m_currentLanguage = l; cbLanguage.Items.Add(l); } lblCurrentLanguage.Text = "[" + m_currentLanguage.ToString() + "]"; //enable/disable community features if (_userId != null) { TvdbUser user = new TvdbUser("user", _userId); m_tvdbHandler.UserInfo = user; List<TvdbSeries> favList = null; try { user.UserPreferredLanguage = m_tvdbHandler.GetPreferredLanguage(); favList = m_tvdbHandler.GetUserFavorites(user.UserPreferredLanguage); } catch (TvdbInvalidApiKeyException ex) { MessageBox.Show(ex.Message); } catch (TvdbNotAvailableException ex) { MessageBox.Show(ex.Message); } if (favList != null) { foreach (TvdbSeries s in favList) { cbUserFavourites.Items.Add(s); } } } else { cbUserFavourites.Text = "No userinfo set"; cbUserFavourites.Enabled = false; } cmdAddRemoveFavorites.Enabled = false; cmdSendSeriesRating.Enabled = false; raterSeriesYourRating.Enabled = false; }
/// <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"); } } }
/// <summary> /// Set the language of the series to one of the languages that have /// already been loaded /// </summary> /// <param name="_language">The new language for this series</param> /// <returns>true if success, false otherwise</returns> public bool SetLanguage(TvdbLanguage _language) { if (m_seriesTranslations.Keys.Contains(_language)) { if (this.Language != null) { if (m_seriesTranslations.Keys.Contains(this.Language)) {//the current language is not added to the dictionary -> add it m_seriesTranslations.Remove(this.Language); } TvdbSeriesFields f = new TvdbSeriesFields(); f.Id = this.Id; f.Actors = this.Actors; f.AirsDayOfWeek = this.AirsDayOfWeek; f.AirsTime = this.AirsTime; f.ContentRating = this.ContentRating; f.FirstAired = this.FirstAired; f.Genre = this.Genre; f.ImdbId = this.ImdbId; f.Language = this.Language; f.Network = this.Network; f.Overview = this.Overview; f.Rating = this.Rating; f.Runtime = this.Runtime; f.TvDotComId = this.TvDotComId; f.SeriesName = this.SeriesName; f.Status = this.Status; f.BannerPath = this.BannerPath; f.FanartPath = this.FanartPath; f.LastUpdated = this.LastUpdated; f.Zap2itId = this.Zap2itId; f.Episodes = this.Episodes; f.EpisodesLoaded = this.EpisodesLoaded; m_seriesTranslations.Add(this.Language, f); } this.UpdateTvdbFields(m_seriesTranslations[_language]); return(true); } else {//the translation hasn't been loaded yet return(false); } }
internal TvdbSeriesFields DownloadSeriesFields(int _seriesId, TvdbLanguage _language) { String xml = ""; String link = ""; try { link = TvdbLinks.CreateSeriesLink(m_apiKey, _seriesId, _language, false, false); xml = m_webClient.DownloadString(link); //extract all series the xml file contains List <TvdbSeriesFields> seriesList = m_xmlHandler.ExtractSeriesFields(xml); if (seriesList != null && seriesList.Count == 1) { return(seriesList[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 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"); } } }
/// <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 xml = ""; String link = ""; try { link = TvdbLinks.CreateEpisodeLink(m_apiKey, _episodeId, _language, false); 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 " + _episodeId + "(" + _language.Abbriviation + "), maybe the episode doesn't exist"); } else { throw new TvdbNotAvailableException("Couldn't connect to Thetvdb.com to retrieve " + _episodeId + ", check your internet connection and the status of http://thetvdb.com"); } } }
/// <summary> /// Set the language of the series to one of the languages that have /// already been loaded /// </summary> /// <param name="_language"></param> /// <returns></returns> public bool SetLanguage(TvdbLanguage _language) { if (m_seriesTranslations.Keys.Contains(_language)) { if (!m_seriesTranslations.Keys.Contains(Language)) { TvdbSeriesFields f = new TvdbSeriesFields(); f.Id = this.Id; f.Actors = this.Actors; f.AirsDayOfWeek = this.AirsDayOfWeek; f.AirsTime = this.AirsTime; f.ContentRating = this.ContentRating; f.FirstAired = this.FirstAired; f.Genre = this.Genre; f.ImdbId = this.ImdbId; f.Language = this.Language; f.Network = this.Network; f.Overview = this.Overview; f.Rating = this.Rating; f.Runtime = this.Runtime; f.TvDotComId = this.TvDotComId; f.SeriesName = this.SeriesName; f.Status = this.Status; f.BannerPath = this.BannerPath; f.FanartPath = this.FanartPath; f.LastUpdated = this.LastUpdated; f.Zap2itId = this.Zap2itId; } m_seriesTranslations[Language].Episodes = this.Episodes; this.UpdateTvdbFields(m_seriesTranslations[_language]); return(true); } else {//the translation hasn't been loaded yet return(false); } }
/// <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; } }
/// <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); } }
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"); } } }
/// <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"); } } }
/// <summary> /// Retrieve the episode with the given parameters /// </summary> /// <param name="_seriesId">id of the series</param> /// <param name="_airDate">When did the episode air</param> /// <param name="_language">language of the episode</param> /// <exception cref="TvdbInvalidApiKeyException">The given api key is not valid</exception> /// <returns>The retrieved episode</returns> public TvdbEpisode GetEpisode(int _seriesId, DateTime _airDate, TvdbLanguage _language) { TvdbEpisode ep = m_downloader.DownloadEpisode(_seriesId, _airDate, _language); return ep; }
internal static String CreateSeriesLinkZipped(String _apiKey, int _seriesId, TvdbLanguage _lang) { return TvdbLinks.ActiveMirror.MirrorPath + "/api/" + _apiKey + "/series/" + _seriesId + "/all/" + (_lang != null ? _lang.Abbriviation : "en") + ".zip"; }
/// <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; } }
/// <summary> /// Gets the full series (including episode information and actors) with the given id either from cache /// (if it has already been loaded) or from the selected tvdb mirror. /// /// To check if this series has already been cached, pleas use the Method IsCached(TvdbSeries _series) /// </summary> /// <exception cref="TvdbNotAvailableException">Tvdb is not available</exception> /// <exception cref="TvdbInvalidApiKeyException">The given api key is not valid</exception> /// <param name="_seriesId">id of series</param> /// <param name="_language">language that should be retrieved</param> /// <param name="_loadBanners">if true also loads the paths to the banners</param> /// <returns>Instance of TvdbSeries containing all gained information</returns> public TvdbSeries GetFullSeries(int _seriesId, TvdbLanguage _language, bool _loadBanners) { return GetSeries(_seriesId, _language, true, true, _loadBanners); }
/// <summary> /// Retrieve the episode with the given id in the given language /// </summary> /// <param name="_episodeId">id of the episode</param> /// <param name="_language">languageof the episode</param> /// <returns>The retrieved episode</returns> public TvdbEpisode GetEpisode(int _episodeId, TvdbLanguage _language) { TvdbEpisode episode = GetEpisodeFromCache(_episodeId, _language); if (episode != null) { return episode; } else { episode = m_downloader.DownloadEpisode(_episodeId, _language); AddEpisodeToCache(episode); return episode; } }
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; } }
/// <summary> /// Parse the short description of a tvdb language and returns the proper /// object. If no such language exists yet (maybe the list of available /// languages hasn't been downloaded yet), a placeholder is created /// </summary> /// <param name="_shortLanguageDesc"></param> /// <returns></returns> internal static TvdbLanguage ParseLanguage(String _shortLanguageDesc) { if (m_languageList != null) { foreach (TvdbLanguage l in m_languageList) { if (l.Abbriviation == _shortLanguageDesc) { return l; } } } else { m_languageList = new List<TvdbLanguage>(); } //the language doesn't exist yet -> create placeholder TvdbLanguage lang = new TvdbLanguage(-99, "unknown", _shortLanguageDesc); m_languageList.Add(lang); return lang; }
/// <summary> /// Extract a list of languages when the data has the format: /// <![CDATA[ /// /// <?xml version="1.0" encoding="UTF-8" ?> /// <Languages> /// <Language> /// <name>Español</name> /// <abbreviation>es</abbreviation> /// <id>16</id> /// </Language> /// </Languages> /// /// ]]> /// </summary> /// <param name="_data"></param> /// <returns></returns> internal List<TvdbLanguage> ExtractLanguages(String _data) { XDocument xml = XDocument.Parse(_data); var allLanguages = from language in xml.Descendants("Language") select new { name = language.Element("name").Value, abbreviation = language.Element("abbreviation").Value, id = language.Element("id").Value }; List<TvdbLanguage> retList = new List<TvdbLanguage>(); foreach (var l in allLanguages) { TvdbLanguage lang = new TvdbLanguage(); lang.Name = l.name; lang.Abbriviation = l.abbreviation; lang.Id = Util.Int32Parse(l.id); if (lang.Id != -99) retList.Add(lang); } return retList; }
/// <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"); } } }
/// <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"); } } }
/// <summary> /// Gets the series with the given id either from cache (if it has already been loaded) or from /// the selected tvdb mirror. If you use zip the request automatically downloads the episodes, the actors and the banners, so you should also select those features. /// /// To check if this series has already been cached, use the Method IsCached(TvdbSeries _series) /// </summary> /// <exception cref="TvdbNotAvailableException">Tvdb is not available</exception> /// <exception cref="TvdbInvalidApiKeyException">The given api key is not valid</exception> /// <param name="_seriesId">id of series</param> /// <param name="_language">language that should be retrieved</param> /// <param name="_loadEpisodes">if true, the full series record will be loaded (series + all episodes), otherwise only the base record will be loaded which contains only series information</param> /// <param name="_loadBanners">if true also loads the paths to the banners</param> /// <param name="_loadActors">if true also loads the extended actor information</param> /// <param name="_useZip">If this series is not already cached and the series has to be downloaded, the zipped version will be downloaded</param> /// <returns>Instance of TvdbSeries containing all gained information</returns> public TvdbSeries GetSeries(int _seriesId, TvdbLanguage _language, bool _loadEpisodes, bool _loadActors, bool _loadBanners, bool _useZip) { Stopwatch watch = new Stopwatch(); watch.Start(); TvdbSeries series = GetSeriesFromCache(_seriesId); if (series == null || //series not yet cached (_useZip && (!series.EpisodesLoaded && !series.TvdbActorsLoaded && !series.BannersLoaded)))//only the basic series info has been loaded -> zip is still faster than fetching the missing informations without using zip {//load complete series from tvdb if (_useZip) { series = m_downloader.DownloadSeriesZipped(_seriesId, _language); } else { series = m_downloader.DownloadSeries(_seriesId, _language, _loadEpisodes, _loadActors, _loadBanners); } if (series == null) { return null; } watch.Stop(); Log.Info("Loaded series in " + watch.ElapsedMilliseconds + " milliseconds"); series.IsFavorite = m_userInfo == null ? false : CheckIfSeriesFavorite(_seriesId, m_userInfo.UserFavorites); AddSeriesToCache(series); return series; } else {//some (if not all) information has already been loaded from tvdb at some point -> fill the missing details and return the series if (!_language.Abbriviation.Equals(series.Language.Abbriviation)) {//user wants a different language than the one that has been loaded if (series.GetAvailableLanguages().Contains(_language)) { series.SetLanguage(_language); } else { TvdbSeriesFields newFields = m_downloader.DownloadSeriesFields(_seriesId, _language); if (_loadEpisodes) { List<TvdbEpisode> epList = m_downloader.DownloadEpisodes(_seriesId, _language); if (epList != null) { newFields.Episodes = epList; } } if (newFields != null) { series.AddLanguage(newFields); series.SetLanguage(_language); } else { Log.Warn("Couldn't load new language " + _language.Abbriviation + " for series " + _seriesId); return null; } } } if (_loadActors && !series.TvdbActorsLoaded) {//user wants actors loaded List<TvdbActor> actorList = m_downloader.DownloadActors(_seriesId); if (actorList != null) { series.TvdbActorsLoaded = true; series.TvdbActors = actorList; } } if (_loadEpisodes && !series.EpisodesLoaded) {//user wants the full version but only the basic has been loaded (without episodes List<TvdbEpisode> epList = m_downloader.DownloadEpisodes(_seriesId, _language); if (epList != null) { series.EpisodesLoaded = true; series.Episodes = epList; } } if (_loadBanners && !series.BannersLoaded) {//user wants banners loaded but current series hasn't -> Do it baby List<TvdbBanner> bannerList = m_downloader.DownloadBanners(_seriesId); if (bannerList != null) { series.BannersLoaded = true; series.Banners = bannerList; } } watch.Stop(); Log.Info("Loaded series in " + watch.ElapsedMilliseconds + " milliseconds"); return series; } }
/// <summary> /// Returns if the series is locally cached /// </summary> /// <param name="_seriesId">Id of the series</param> /// <param name="_language">Language</param> /// <param name="_loadEpisodes">Load Episodes</param> /// <param name="_loadActors">Load Actors</param> /// <param name="_loadBanners">Load Banners</param> /// <returns>True if the series is cached in the given configuration</returns> public bool IsCached(int _seriesId, TvdbLanguage _language, bool _loadEpisodes, bool _loadActors, bool _loadBanners) { foreach (TvdbSeries s in m_loadedData.SeriesList) { if (s.Id == _seriesId && s.Language.Abbriviation.Equals(_language.Abbriviation)) { if ((s.BannersLoaded || !_loadActors) && (s.TvdbActorsLoaded || !_loadActors) && (s.EpisodesLoaded || !_loadEpisodes)) { return true; } } } if (m_cacheProvider != null) { return m_cacheProvider.IsCached(_seriesId, _loadEpisodes, _loadBanners, _loadActors); } return false; }
/// <summary> /// Gets the basic series (without episode information and actors) with the given id either from cache /// (if it has already been loaded) or from the selected tvdb mirror. /// /// To check if this series has already been cached, please use the Method IsCached(TvdbSeries _series) /// </summary> /// <exception cref="TvdbNotAvailableException">Tvdb is not available</exception> /// <exception cref="TvdbInvalidApiKeyException">The given api key is not valid</exception> /// <param name="_seriesId">id of series</param> /// <param name="_language">language that should be retrieved</param> /// <param name="_loadBanners">if true also loads the paths to the banners</param> /// <returns>Instance of TvdbSeries containing all gained information</returns> public TvdbSeries GetBasicSeries(int _seriesId, TvdbLanguage _language, bool _loadBanners) { return GetSeries(_seriesId, _language, false, false, _loadBanners); }
/// <summary> /// /// </summary> /// <param name="_episodeId"></param> /// <param name="_language"></param> /// <returns></returns> private TvdbEpisode GetEpisodeFromCache(int _episodeId, TvdbLanguage _language) { foreach (TvdbSeries s in m_loadedData.SeriesList) { foreach (TvdbEpisode e in s.Episodes) { if (e.Id == _episodeId) { return e; } } } return null; }
/// <summary> /// Retrieve the episode with the given parameters /// </summary> /// <param name="_seriesId">id of the series</param> /// <param name="_seasonNr">season number of the episode</param> /// <param name="_episodeNr">number of the episode</param> /// <param name="_language">language of the episode</param> /// <param name="_order">The sorting order that should be user when downloading the episode</param> /// <returns>The retrieved episode</returns> public TvdbEpisode GetEpisode(int _seriesId, int _seasonNr, int _episodeNr, TvdbEpisode.EpisodeOrdering _order, TvdbLanguage _language) { String order = null; switch (_order) { case TvdbEpisode.EpisodeOrdering.AbsoluteOrder: order = "absolut"; break; case TvdbEpisode.EpisodeOrdering.DefaultOrder: order = "default"; break; case TvdbEpisode.EpisodeOrdering.DvdOrder: order = "dvd"; break; } TvdbEpisode episode = m_downloader.DownloadEpisode(_seriesId, _seasonNr, _episodeNr, order, _language); return episode; }
internal static String CreateSeriesEpisodesLink(String _apiKey, int _seriesId, TvdbLanguage _lang) { //this in fact returns the "full series page (http://thetvdb.com/wiki/index.php/API:Full_Series_Record) //which sucks because to retrieve all episodes I have to also download the series information (which isn't) //all that big on the other hand return TvdbLinks.ActiveMirror.MirrorPath + "/api/" + _apiKey + "/series/" + _seriesId + "/all/" + (_lang != null ? _lang.Abbriviation : "en") + ".xml"; }
/// <summary> /// Gets the series with the given id either from cache (if it has already been loaded) or from /// the selected tvdb mirror. /// /// To check if this series has already been cached, use the Method IsCached(TvdbSeries _series) /// </summary> /// <exception cref="TvdbNotAvailableException">Tvdb is not available</exception> /// <exception cref="TvdbInvalidApiKeyException">The given api key is not valid</exception> /// <param name="_seriesId">id of series</param> /// <param name="_language">language that should be retrieved</param> /// <param name="_loadEpisodes">if true, the full series record will be loaded (series + all episodes), otherwise only the base record will be loaded which contains only series information</param> /// <param name="_loadActors">if true also loads the extended actor information</param> /// <param name="_loadBanners">if true also loads the paths to the banners</param> /// <returns>Instance of TvdbSeries containing all gained information</returns> public TvdbSeries GetSeries(int _seriesId, TvdbLanguage _language, bool _loadEpisodes, bool _loadActors, bool _loadBanners) { return GetSeries(_seriesId, _language, _loadEpisodes, _loadActors, _loadBanners, false); }
/// <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> /// Get the favorite series of the user (only basic series information will be loaded) /// </summary> /// <param name="_lang">Which language should be used</param> /// <returns>List of favorite series</returns> public List<TvdbSeries> GetUserFavorites(TvdbLanguage _lang) { if (m_userInfo != null) { if (_lang != null) { List<int> idList = GetUserFavouritesList(); List<TvdbSeries> retList = new List<TvdbSeries>(); foreach (int sId in idList) { if (IsCached(sId, _lang, false, false, false)) { retList.Add(GetSeriesFromCache(sId)); } else { TvdbSeries series = m_downloader.DownloadSeries(sId, _lang, false, false, false); if (series != null) { retList.Add(series); } AddSeriesToCache(series); } } HandleUserFavoriteRetrieved(idList); return retList; } else { throw new Exception("you have to define a language"); } } else { throw new TvdbUserNotFoundException("You can't get the favourites when no user is defined"); } }
/// <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"); } } }
/// <summary> /// Gets the series with the given id either from cache (if it has already been loaded) or from /// the selected tvdb mirror. If this series is not already cached and the series has to be /// downloaded, the zipped version will be downloaded /// /// To check if this series has already been cached, use the Method IsCached(TvdbSeries _series) /// </summary> /// <exception cref="TvdbNotAvailableException">Tvdb is not available</exception> /// <exception cref="TvdbInvalidApiKeyException">The given api key is not valid</exception> /// <param name="_seriesId">id of series</param> /// <param name="_language">language that should be retrieved</param> /// <returns>Instance of TvdbSeries containing all gained information</returns> internal TvdbSeries GetSeriesZipped(int _seriesId, TvdbLanguage _language) { return GetSeries(_seriesId, _language, true, true, true, true); }
/// <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; }
internal static string CreateEpisodeLink(string _apiKey, int _seriesId, int _seasonNr, int _episodeNr, string _order, TvdbLanguage _lang) { return TvdbLinks.ActiveMirror.MirrorPath + "/api/" + _apiKey + "/series/" + _seriesId + "/" + _order + "/" + _seasonNr + "/" + "/" + _episodeNr + "/" + (_lang != null ? _lang.Abbriviation : "en") + ".xml"; }
/// <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 data; try { data = m_webClient.DownloadString(TvdbLinks.CreateSeriesLink(m_apiKey, _seriesId, _language, _loadEpisodes, 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<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; } }
internal static String CreateSeriesLink(String _apiKey, int _seriesId, TvdbLanguage _lang, bool _full, bool _zipped) { return TvdbLinks.ActiveMirror.MirrorPath + "/api/" + _apiKey + "/series/" + _seriesId + (_full ? "/all/" : "/") + (_lang != null ? _lang.Abbriviation : "en") + ".xml"; }
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; } }
internal static String CreateEpisodeLink(string _apiKey, int _episodeId, TvdbLanguage _lang, bool p) { return TvdbLinks.ActiveMirror.MirrorPath + "/api/" + _apiKey + "/episodes/" + _episodeId + "/" + (_lang != null ? _lang.Abbriviation : "en") + ".xml"; }
internal TvdbSeries DownloadSeriesZipped(int _seriesId, TvdbLanguage _language) { //download the xml data from this request byte[] data; try { data = m_webClient.DownloadData(TvdbLinks.CreateSeriesLinkZipped(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 " + _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"); } } ZipInputStream zip = new ZipInputStream(new MemoryStream(data)); 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; } }