private void FillSeriesDetails(TvdbSeries series) { if (m_tvdbHandler.UserInfo != null) { cmdAddRemoveFavorites.Enabled = true; cmdAddRemoveFavorites.Text = series.IsFavorite ? "Remove from favorites" : "Add to favorites"; cmdSendSeriesRating.Enabled = true; raterSeriesYourRating.Enabled = true; } else { cmdAddRemoveFavorites.Enabled = false; cmdSendSeriesRating.Enabled = false; raterSeriesYourRating.Enabled = false; } List <TvdbBanner> bannerlist = new List <TvdbBanner>(); foreach (TvdbBanner b in series.Banners) { if (b.GetType() == typeof(TvdbSeriesBanner)) { //if (b.Language.Id == m_defaultLang.Id) { bannerlist.Add(b); } } } if (bannerlist.Count > 0) { bcSeriesBanner.BannerImages = bannerlist; } else { bcSeriesBanner.ClearControl(); } txtSeriesId.Text = series.Id.ToString(); txtSeriesName.Text = series.SeriesName; txtStatus.Text = series.Status; txtGenre.Text = series.GenreString; txtFirstAired.Text = series.FirstAired != null?series.FirstAired.ToShortDateString() : ""; txtAirsWeekday.Text = series.AirsDayOfWeek != null?series.AirsDayOfWeek.ToString() : ""; txtAirstime.Text = series.AirsTime.ToShortTimeString(); txtNetwork.Text = series.Network; txtRuntime.Text = series.Runtime != -99 ? series.Runtime.ToString() : ""; txtRating.Text = series.Rating != -99 ? series.Rating.ToString() : ""; txtActors.Text = series.ActorsString; txtOverview.Text = series.Overview; txtTvComId.Text = series.TvDotComId != -99 ? series.TvDotComId.ToString() : ""; //series. if (series.TvDotComId != -99) { String link = "http://www.tv.com/show/" + series.TvDotComId + "/summary.html"; llblTvComId.Text = "Open"; llblTvComId.Links.Clear(); llblTvComId.Links.Add(0, link.Length, link); } else { llblTvComId.Links.Clear(); llblTvComId.Text = ""; } txtImdbId.Text = series.ImdbId; if (series.ImdbId != null && !series.ImdbId.Equals("")) { String link = "http://www.imdb.com/title/" + series.ImdbId; llblImdb.Text = "Open"; llblImdb.Links.Clear(); llblImdb.Links.Add(0, link.Length, link); } else { llblImdb.Links.Clear(); llblImdb.Text = ""; } txtZap2itId.Text = series.Zap2itId; raterSeriesSiteRating.CurrentRating = series.Rating != -99 ? (int)(series.Rating / 10) : 0; }
/// <summary> /// Create the series content /// </summary> /// <param name="_series">Series to store</param> /// <returns>xml content</returns> internal String CreateSeriesContent(TvdbSeries _series) { XElement xml = new XElement("Data"); xml.Add(new XElement("Series", new XElement("id", _series.Id), new XElement("Actors", _series.ActorsString), new XElement("Airs_DayOfWeek", _series.AirsDayOfWeek), new XElement("Airs_Time", _series.AirsTime), new XElement("ContentRating", _series.ContentRating), new XElement("FirstAired", _series.FirstAired), new XElement("Genre", _series.GenreString), new XElement("IMDB_ID", _series.ImdbId), new XElement("Language", _series.Language.Abbriviation), new XElement("Network", _series.Network), new XElement("Overview", _series.Overview), new XElement("Rating", _series.Rating), new XElement("Runtime", _series.Runtime), new XElement("SeriesID", _series.TvDotComId), new XElement("SeriesName", _series.SeriesName), new XElement("Status", _series.Status), new XElement("banner", _series.BannerPath != null ? _series.BannerPath : ""), new XElement("fanart", _series.FanartPath != null ? _series.FanartPath : ""), new XElement("lastupdated", Util.DotNetToUnix(_series.LastUpdated)), new XElement("zap2it_id", _series.Zap2itId)) ); if (_series.Episodes != null && _series.EpisodesLoaded) { foreach (TvdbEpisode e in _series.Episodes) { xml.Add(new XElement("Episode", new XElement("id", e.Id), new XElement("Combined_episodenumber", e.CombinedEpisodeNumber), new XElement("Combined_season", e.CombinedSeason), new XElement("DVD_chapter", e.DvdChapter != -99 ? e.DvdChapter.ToString() : ""), new XElement("DVD_discid", e.DvdDiscId != -99 ? e.DvdDiscId.ToString() : ""), new XElement("DVD_episodenumber", e.DvdEpisodeNumber != -99 ? e.DvdEpisodeNumber.ToString() : ""), new XElement("DVD_season", e.DvdSeason != -99 ? e.DvdSeason.ToString() : ""), new XElement("Director", e.DirectorsString), new XElement("EpisodeName", e.EpisodeName), new XElement("EpisodeNumber", e.EpisodeNumber), new XElement("FirstAired", e.FirstAired), new XElement("GuestStars", e.GuestStarsString), new XElement("IMDB_ID", e.ImdbId), new XElement("Language", e.Language.Name), new XElement("Overview", e.Overview), new XElement("ProductionCode", e.ProductionCode), new XElement("Rating", e.Rating.ToString()), new XElement("SeasonNumber", e.SeasonNumber), new XElement("Writer", e.WriterString), new XElement("absolute_number", e.AbsoluteNumber), new XElement("airsafter_season", e.AirsAfterSeason != -99 ? e.AirsAfterSeason.ToString() : ""), new XElement("airsbefore_episode", e.AirsBeforeEpisode != -99 ? e.AirsBeforeEpisode.ToString() : ""), new XElement("airsbefore_season", e.AirsBeforeSeason != -99 ? e.AirsBeforeSeason.ToString() : ""), new XElement("filename", e.BannerPath), new XElement("lastupdated", Util.DotNetToUnix(e.LastUpdated)), new XElement("seasonid", e.SeasonId), new XElement("seriesid", e.SeriesId)) ); } } return(xml.ToString()); }
/// <summary> /// Load the give series from cache /// </summary> /// <param name="seriesId">Id of the series to load</param> /// <returns>Series that has been loaded or null if series doesn't exist</returns> public TvdbSeries LoadSeriesFromCache(int seriesId) { String seriesRoot = _rootFolder + Path.DirectorySeparatorChar + seriesId; if (!Directory.Exists(seriesRoot)) { return(null); } TvdbSeries series = new TvdbSeries(); _seriesLock.EnterReadLock(); try { #region load series in all available languages String[] seriesLanguages = Directory.GetFiles(seriesRoot, "*.xml"); foreach (String l in seriesLanguages) { if (!l.EndsWith("actors.xml") && !l.EndsWith("banners.xml")) { String content = File.ReadAllText(l); List <TvdbSeriesFields> seriesList = _xmlReader.ExtractSeriesFields(content); if (seriesList != null && seriesList.Count == 1) { TvdbSeriesFields s = seriesList[0]; //Load episodes if (l.EndsWith("full.xml")) { List <TvdbEpisode> epList = _xmlReader.ExtractEpisodes(content); s.EpisodesLoaded = true; s.Episodes.Clear(); s.Episodes.AddRange(epList); } series.AddLanguage(s); } } } if (series.SeriesTranslations.Count > 0) { //change language of the series to the default language series.SetLanguage(series.SeriesTranslations.Keys.First()); } else { //no series info could be loaded return(null); } if (!series.BannerPath.Equals("")) { series.Banners.Add(new TvdbSeriesBanner(series.Id, series.BannerPath, series.Language, TvdbSeriesBanner.Type.Graphical)); } if (!series.PosterPath.Equals("")) { series.Banners.Add(new TvdbPosterBanner(series.Id, series.PosterPath, series.Language)); } if (!series.FanartPath.Equals("")) { series.Banners.Add(new TvdbFanartBanner(series.Id, series.FanartPath, series.Language)); } Regex rex = new Regex("S(\\d+)E(\\d+)"); if (Directory.Exists(seriesRoot + Path.DirectorySeparatorChar + "EpisodeImages")) { String[] episodeFiles = Directory.GetFiles(seriesRoot + Path.DirectorySeparatorChar + "EpisodeImages", "ep_*.jpg"); foreach (String epImageFile in episodeFiles) { try { Match match = rex.Match(epImageFile); int season = Int32.Parse(match.Groups[1].Value); int episode = Int32.Parse(match.Groups[2].Value); foreach (TvdbEpisode e in series.Episodes.Where(e => e.SeasonNumber == season && e.EpisodeNumber == episode)) { if (epImageFile.Contains("thumb")) { e.Banner.LoadThumb(Image.FromFile(epImageFile)); } else { e.Banner.LoadBanner(Image.FromFile(epImageFile)); } break; } } catch (Exception) { Log.Warn("Couldn't load episode image file " + epImageFile); } } } #endregion #region Banner loading String bannerFile = seriesRoot + Path.DirectorySeparatorChar + "banners.xml"; //load cached banners if (File.Exists(bannerFile)) { //banners have been already loaded List <TvdbBanner> bannerList = _xmlReader.ExtractBanners(File.ReadAllText(bannerFile)); String[] banners = Directory.GetFiles(seriesRoot, "banner*.jpg"); foreach (String b in banners) { try { int bannerId = Int32.Parse(b.Remove(b.IndexOf(".")).Remove(0, b.LastIndexOf("_") + 1)); foreach (TvdbBanner banner in bannerList.Where(banner => banner.Id == bannerId)) { if (b.Contains("thumb") && banner.GetType().BaseType == typeof(TvdbBannerWithThumb)) { ((TvdbBannerWithThumb)banner).LoadThumb(Image.FromFile(b)); } else if (b.Contains("vignette") && banner.GetType() == typeof(TvdbFanartBanner)) { ((TvdbFanartBanner)banner).LoadVignette(Image.FromFile(b)); } else { banner.LoadBanner(Image.FromFile(b)); } } } catch (Exception) { Log.Warn("Couldn't load image file " + b); } } series.Banners = bannerList; } #endregion #region actor loading //load actor info String actorFile = seriesRoot + Path.DirectorySeparatorChar + "actors.xml"; if (File.Exists(actorFile)) { List <TvdbActor> actorList = _xmlReader.ExtractActors(File.ReadAllText(actorFile)); String[] banners = Directory.GetFiles(seriesRoot, "actor_*.jpg"); foreach (String b in banners) { try { int actorId = Int32.Parse(b.Remove(b.IndexOf(".")).Remove(0, b.LastIndexOf("_") + 1)); foreach (TvdbActor actor in actorList.Where(actor => actor.Id == actorId)) { actor.ActorImage.LoadBanner(Image.FromFile(b)); } } catch (Exception) { Log.Warn("Couldn't load image file " + b); } } series.TvdbActors = actorList; } #endregion } finally { _seriesLock.ExitReadLock(); } return(series); }
/// <summary> /// Saves the series to cache /// </summary> /// <param name="_series"></param> public void SaveToCache(TvdbSeries _series) { if (_series != null) { String seriesRoot = m_rootFolder + Path.DirectorySeparatorChar + _series.Id; if (!Directory.Exists(seriesRoot)) { Directory.CreateDirectory(seriesRoot); } #region delete all loaded images (since they should be already cached) //delete banners foreach (TvdbBanner b in _series.Banners) { if (b.IsLoaded) {//banner is loaded b.UnloadBanner(); } //remove the ref to the cacheprovider b.CacheProvider = null; if (b.GetType() == typeof(TvdbBannerWithThumb)) {//thumb is loaded if (((TvdbBannerWithThumb)b).IsThumbLoaded) { ((TvdbBannerWithThumb)b).UnloadThumb(); } } if (b.GetType() == typeof(TvdbFanartBanner)) {//vignette is loaded if (((TvdbFanartBanner)b).IsVignetteLoaded) { ((TvdbFanartBanner)b).UnloadVignette(); } } } //delete Actor Images if (_series.TvdbActorsLoaded) { foreach (TvdbActor a in _series.TvdbActors) { if (a.ActorImage.IsLoaded) { a.ActorImage.UnloadBanner(); } //remove the ref to the cacheprovider a.ActorImage.CacheProvider = null; } } //delete episode images if (_series.EpisodesLoaded) { foreach (TvdbEpisode e in _series.Episodes) { if (e.Banner.IsLoaded) { e.Banner.UnloadBanner(); } //remove the ref to the cacheprovider e.Banner.CacheProvider = null; } } #endregion //serialize series to hdd m_filestream = new FileStream(seriesRoot + Path.DirectorySeparatorChar + "series_" + _series.Id + ".ser", FileMode.Create); m_formatter.Serialize(m_filestream, _series); m_filestream.Close(); //serialize series config to hdd SeriesConfiguration cfg = new SeriesConfiguration(_series.Id, _series.EpisodesLoaded, _series.BannersLoaded, _series.TvdbActorsLoaded); m_filestream = new FileStream(seriesRoot + Path.DirectorySeparatorChar + "series_" + _series.Id + ".cfg", FileMode.Create); m_formatter.Serialize(m_filestream, cfg); m_filestream.Close(); } }
/// <summary> /// Removes the series from the users list of favorites and returns the new list of /// favorites /// </summary> /// <param name="_series">series to remove from the favorites</param> /// <returns>new list with all favorites</returns> public List <int> RemoveSeriesFromFavorites(TvdbSeries _series) { return(RemoveSeriesFromFavorites(_series.Id)); }
private bool MakeUpdate(Util.UpdateInterval _interval, bool _zipped) { Log.Info("Started update (" + _interval.ToString() + ")"); Stopwatch watch = new Stopwatch(); watch.Start(); //update all flagged series List <TvdbSeries> updateSeries; List <TvdbEpisode> updateEpisodes; List <TvdbBanner> updateBanners; DateTime updateTime = m_downloader.DownloadUpdate(out updateSeries, out updateEpisodes, out updateBanners, _interval, _zipped); List <int> cachedSeries = m_cacheProvider.GetCachedSeries(); List <TvdbSeries> seriesToSave = new List <TvdbSeries>(); foreach (TvdbSeries us in updateSeries) { foreach (TvdbSeries s in m_loadedData.SeriesList) { if (us.Id == s.Id) { if (s.LastUpdated < us.LastUpdated) {//changes occured in series UpdateSeries(s, us.LastUpdated); } break; } } //Update series that have been already cached but are not in memory foreach (int s in cachedSeries) { if (us.Id == s) {//changes occured in series TvdbSeries series = m_cacheProvider.LoadSeriesFromCache(us.Id); if (series.LastUpdated < us.LastUpdated) { UpdateSeries(series, us.LastUpdated); AddSeriesToCache(series); seriesToSave.Add(series); } break; } } } //update all flagged episodes foreach (TvdbEpisode ue in updateEpisodes) { foreach (TvdbSeries s in m_loadedData.SeriesList) { if (ue.SeriesId == s.Id) { UpdateEpisode(s, ue); break; } } foreach (int s in cachedSeries) { if (ue.SeriesId == s) {//changes occured in series TvdbSeries series = m_cacheProvider.LoadSeriesFromCache(ue.SeriesId); UpdateEpisode(series, ue); break; } } } //todo: update banner information here -> wait for forum response regarding missing foreach (TvdbBanner b in updateBanners) { foreach (TvdbSeries s in m_loadedData.SeriesList) { if (s.Id == b.SeriesId) { UpdateBanner(s, b); break; } } foreach (int s in cachedSeries) { if (b.SeriesId == s) {//changes occured in series TvdbSeries series = m_cacheProvider.LoadSeriesFromCache(s); UpdateBanner(series, b); break; } } } //set the last updated time to time of this update m_loadedData.LastUpdated = updateTime; watch.Stop(); Log.Info("Finished update (" + _interval.ToString() + ") in " + watch.ElapsedMilliseconds + " milliseconds"); return(true); }
public override async Task <List <EpisodeInfo> > SearchSeriesEpisodeAsync(EpisodeInfo episodeSearch, TvdbLanguage language) { language = language ?? PreferredLanguage; SeriesInfo seriesSearch = episodeSearch.CloneBasicInstance <SeriesInfo>(); if (episodeSearch.SeriesTvdbId <= 0 && string.IsNullOrEmpty(episodeSearch.SeriesImdbId)) { if (!await SearchSeriesUniqueAndUpdateAsync(seriesSearch, language).ConfigureAwait(false)) { return(null); } episodeSearch.CopyIdsFrom(seriesSearch); } List <EpisodeInfo> episodes = null; if ((episodeSearch.SeriesTvdbId > 0 || !string.IsNullOrEmpty(episodeSearch.SeriesImdbId)) && episodeSearch.SeasonNumber.HasValue) { int seriesId = 0; if (episodeSearch.SeriesTvdbId > 0) { seriesId = episodeSearch.SeriesTvdbId; } else if (!string.IsNullOrEmpty(episodeSearch.SeriesImdbId)) { TvdbSearchResult searchResult = await _tvdbHandler.GetSeriesByRemoteIdAsync(ExternalId.ImdbId, episodeSearch.SeriesImdbId); if (searchResult?.Id > 0) { seriesId = searchResult.Id; } } TvdbSeries seriesDetail = await _tvdbHandler.GetSeriesAsync(seriesId, language, true, false, false).ConfigureAwait(false); if (seriesDetail == null) { return(null); } foreach (TvdbEpisode episode in seriesDetail.Episodes.OrderByDescending(e => e.Id)) { if ((episodeSearch.EpisodeNumbers.Contains(episode.EpisodeNumber) || episodeSearch.EpisodeNumbers.Count == 0) && (episodeSearch.SeasonNumber == episode.SeasonNumber || episodeSearch.SeasonNumber.HasValue == false)) { if (episodes == null) { episodes = new List <EpisodeInfo>(); } EpisodeInfo info = new EpisodeInfo { TvdbId = episode.Id, SeriesName = new SimpleTitle(seriesDetail.SeriesName, false), SeasonNumber = episode.SeasonNumber, EpisodeName = new SimpleTitle(episode.EpisodeName, false), DataProviders = new List <string>() { _name } }; info.EpisodeNumbers.Add(episode.EpisodeNumber); info.CopyIdsFrom(seriesSearch); info.Languages.Add(episode.Language.Abbriviation); if (!episodes.Contains(info)) { episodes.Add(info); } } } if (episodes != null) { episodes.Sort(); } } if (episodes == null) { episodes = new List <EpisodeInfo>(); EpisodeInfo info = new EpisodeInfo { SeriesName = seriesSearch.SeriesName, SeasonNumber = episodeSearch.SeasonNumber, EpisodeName = episodeSearch.EpisodeName, DataProviders = new List <string>() { _name } }; info.CopyIdsFrom(seriesSearch); info.EpisodeNumbers = info.EpisodeNumbers.Union(episodeSearch.EpisodeNumbers).ToList(); info.Languages = seriesSearch.Languages; episodes.Add(info); } return(episodes); }
private void UpdateSeries(TvdbSeries _series) { m_currentSeries = _series; FillSeriesDetails(_series); cmdForceUpdate.Enabled = true; if (_series.BannersLoaded) { cmdLoadBanners.Enabled = false; pnlFanartEnabled.Visible = false; if (_series.PosterBanners.Count > 0) { posterControlSeries.PosterImages = _series.PosterBanners; } else { posterControlSeries.ClearPoster(); } } else { cmdLoadBanners.Enabled = true; pnlFanartEnabled.Visible = true; } if (_series.EpisodesLoaded) { cmdLoadFullSeriesInfo.Enabled = false; pnlEpisodeEnabled.Visible = false; FillFullSeriesDetails(_series); } else { cmdLoadFullSeriesInfo.Enabled = true; pnlEpisodeEnabled.Visible = true; } if (_series.TvdbActorsLoaded && _series.Actors.Count > 0) { cmdLoadActorInfo.Enabled = false; pnlActorsEnabled.Visible = false; lbAllActors.Items.Clear(); bcActors.ClearControl(); if (_series.TvdbActors.Count > 0) { List <TvdbBanner> bannerList = new List <TvdbBanner>(); foreach (TvdbActor a in _series.TvdbActors) { lbAllActors.Items.Add(a.Name); bannerList.Add(a.ActorImage); } bcActors.BannerImages = bannerList; SetActorInfo(_series.TvdbActors[0]); } } else { bcActors.ClearControl(); cmdLoadActorInfo.Enabled = true; pnlActorsEnabled.Visible = true; } }
/// <summary> /// Gets Series information from TvDB. Results will be added automatically to cache. /// </summary> /// <param name="seriesId">TvDB ID of series</param> /// <param name="loadEpisodes"><c>true</c> to load episodes</param> /// <param name="series">Returns the Series information</param> /// <returns><c>true</c> if successful</returns> public bool GetSeries(int seriesId, bool loadEpisodes, out TvdbSeries series) { series = _tvdbHandler.GetSeries(seriesId, PreferredLanguage, loadEpisodes, false, false); return(series != null); }
/// <summary> /// Gets Series information from TvDB. Results will be added automatically to cache. /// </summary> /// <param name="seriesId">TvDB ID of series</param> /// <param name="series">Returns the Series information</param> /// <returns><c>true</c> if successful</returns> public bool GetSeriesFanArt(int seriesId, out TvdbSeries series) { series = _tvdbHandler.GetSeries(seriesId, PreferredLanguage, false, false, true); return(series != null); }
public override void CreateForSeries(Series series, TvdbSeries tvDbSeries) { //Create tvshow.nfo, fanart.jpg, folder.jpg and season##.tbn var episodeGuideUrl = GetEpisodeGuideUrl(series.SeriesId); _logger.Debug("Generating tvshow.nfo for: {0}", series.Title); var sb = new StringBuilder(); var xws = new XmlWriterSettings(); xws.OmitXmlDeclaration = true; xws.Indent = false; using (var xw = XmlWriter.Create(sb, xws)) { var tvShow = new XElement("tvshow"); tvShow.Add(new XElement("title", tvDbSeries.SeriesName)); tvShow.Add(new XElement("rating", tvDbSeries.Rating)); tvShow.Add(new XElement("plot", tvDbSeries.Overview)); tvShow.Add(new XElement("episodeguide", new XElement("url", episodeGuideUrl))); tvShow.Add(new XElement("episodeguideurl", episodeGuideUrl)); tvShow.Add(new XElement("mpaa", tvDbSeries.ContentRating)); tvShow.Add(new XElement("id", tvDbSeries.Id)); tvShow.Add(new XElement("genre", tvDbSeries.GenreString.Trim('|').Split('|')[0])); tvShow.Add(new XElement("premiered", tvDbSeries.FirstAired.ToString("yyyy-MM-dd"))); tvShow.Add(new XElement("studio", tvDbSeries.Network)); foreach (var actor in tvDbSeries.TvdbActors) { tvShow.Add(new XElement("actor", new XElement("name", actor.Name), new XElement("role", actor.Role), new XElement("thumb", "http://www.thetvdb.com/banners/" + actor.ActorImage.BannerPath) )); } var doc = new XDocument(tvShow); doc.Save(xw); _logger.Debug("Saving tvshow.nfo for {0}", series.Title); _diskProvider.WriteAllText(Path.Combine(series.Path, "tvshow.nfo"), doc.ToString()); } if (String.IsNullOrWhiteSpace(tvDbSeries.FanartPath)) { _logger.Debug("Fanart does not exist for series: {0}, skipping.", series.Title); } else { if (!_diskProvider.FileExists(Path.Combine(series.Path, "fanart.jpg"))) { _logger.Debug("Downloading fanart for: {0}", series.Title); _bannerProvider.Download(tvDbSeries.FanartPath, Path.Combine(series.Path, "fanart.jpg")); } } if (!_diskProvider.FileExists(Path.Combine(series.Path, "folder.jpg"))) { if (_configProvider.MetadataUseBanners) { if (!String.IsNullOrWhiteSpace(tvDbSeries.BannerPath)) { _logger.Debug("Downloading series banner for: {0}", series.Title); _bannerProvider.Download(tvDbSeries.BannerPath, Path.Combine(series.Path, "folder.jpg")); } _logger.Debug("Downloading Season banners for {0}", series.Title); DownloadSeasonThumbnails(series, tvDbSeries, TvdbSeasonBanner.Type.seasonwide); } else { if (!String.IsNullOrWhiteSpace(tvDbSeries.PosterPath)) { _logger.Debug("Downloading series thumbnail for: {0}", series.Title); _bannerProvider.Download(tvDbSeries.PosterPath, Path.Combine(series.Path, "folder.jpg")); } _logger.Debug("Downloading Season posters for {0}", series.Title); DownloadSeasonThumbnails(series, tvDbSeries, TvdbSeasonBanner.Type.season); } } }
public override void CreateForEpisodeFile(EpisodeFile episodeFile, TvdbSeries tvDbSeries) { //Create filename.tbn and filename.nfo var episodes = _episodeProvider.GetEpisodesByFileId(episodeFile.EpisodeFileId); if (!episodes.Any()) { _logger.Debug("No episodes where found for this episode file: {0}", episodeFile.EpisodeFileId); return; } var episodeFileThumbnail = tvDbSeries.Episodes.FirstOrDefault( e => e.SeasonNumber == episodeFile.SeasonNumber && e.EpisodeNumber == episodes.First().EpisodeNumber); if (episodeFileThumbnail == null || String.IsNullOrWhiteSpace(episodeFileThumbnail.BannerPath)) { _logger.Debug("No thumbnail is available for this episode"); } else { if (!_diskProvider.FileExists(episodeFile.Path.Replace(Path.GetExtension(episodeFile.Path), ".tbn"))) { _logger.Debug("Downloading episode thumbnail for: {0}", episodeFile.EpisodeFileId); _bannerProvider.Download(episodeFileThumbnail.BannerPath, episodeFile.Path.Replace(Path.GetExtension(episodeFile.Path), ".tbn")); } } _logger.Debug("Generating filename.nfo for: {0}", episodeFile.EpisodeFileId); var xmlResult = String.Empty; foreach (var episode in episodes) { var sb = new StringBuilder(); var xws = new XmlWriterSettings(); xws.OmitXmlDeclaration = true; xws.Indent = false; using (var xw = XmlWriter.Create(sb, xws)) { var doc = new XDocument(); var tvdbEpisode = tvDbSeries.Episodes.FirstOrDefault( e => e.Id == episode.TvDbEpisodeId); if (tvdbEpisode == null) { _logger.Debug("Looking up by TvDbEpisodeId failed, trying to match via season/episode number combination"); tvdbEpisode = tvDbSeries.Episodes.FirstOrDefault( e => e.SeasonNumber == episode.SeasonNumber && e.EpisodeNumber == episode.EpisodeNumber); } if (tvdbEpisode == null) { _logger.Debug("Unable to find episode from TvDb - skipping"); return; } var details = new XElement("episodedetails"); details.Add(new XElement("title", tvdbEpisode.EpisodeName)); details.Add(new XElement("season", tvdbEpisode.SeasonNumber)); details.Add(new XElement("episode", tvdbEpisode.EpisodeNumber)); details.Add(new XElement("aired", tvdbEpisode.FirstAired.ToString("yyyy-MM-dd"))); details.Add(new XElement("plot", tvdbEpisode.Overview)); details.Add(new XElement("displayseason")); details.Add(new XElement("displayepisode")); details.Add(new XElement("thumb", "http://www.thetvdb.com/banners/" + tvdbEpisode.BannerPath)); details.Add(new XElement("watched", "false")); details.Add(new XElement("credits", tvdbEpisode.Writer.FirstOrDefault())); details.Add(new XElement("director", tvdbEpisode.Directors.FirstOrDefault())); details.Add(new XElement("rating", tvdbEpisode.Rating)); foreach (var actor in tvdbEpisode.GuestStars) { if (!String.IsNullOrWhiteSpace(actor)) { continue; } details.Add(new XElement("actor", new XElement("name", actor) )); } foreach (var actor in tvDbSeries.TvdbActors) { details.Add(new XElement("actor", new XElement("name", actor.Name), new XElement("role", actor.Role), new XElement("thumb", "http://www.thetvdb.com/banners/" + actor.ActorImage.BannerPath) )); } doc.Add(details); doc.Save(xw); xmlResult += doc.ToString(); xmlResult += Environment.NewLine; } } var filename = episodeFile.Path.Replace(Path.GetExtension(episodeFile.Path), ".nfo"); _logger.Debug("Saving episodedetails to: {0}", filename); _diskProvider.WriteAllText(filename, xmlResult.Trim(EnvironmentProvider.NewLineChars)); }
/// <summary> /// Load the give series from cache /// </summary> /// <param name="_seriesId">Id of the series to load</param> /// <returns>Series that has been loaded</returns> public TvdbSeries LoadSeriesFromCache(int _seriesId) { String seriesRoot = m_rootFolder + "\\" + _seriesId; //todo: handle languages TvdbSeries series = new TvdbSeries(); #region load series in all available languages String[] seriesLanguages = Directory.GetFiles(seriesRoot, "*.xml"); TvdbLanguage defaultLanguage = null;; foreach (String l in seriesLanguages) { if (!l.EndsWith("actors.xml") && !l.EndsWith("banners.xml")) { String content = File.ReadAllText(l); List <TvdbSeriesFields> seriesList = m_xmlReader.ExtractSeriesFields(content); if (seriesList != null && seriesList.Count == 1) { TvdbSeriesFields s = seriesList[0]; if (l.EndsWith("all.xml")) { defaultLanguage = s.Language; } //Load episodes List <TvdbEpisode> epList = m_xmlReader.ExtractEpisodes(content); if (epList != null && epList.Count > 0) { s.EpisodesLoaded = true; s.Episodes = epList; } series.AddLanguage(s); } } } if (defaultLanguage != null) {//change language of the series to the default language series.SetLanguage(defaultLanguage); } else {//no series info could be loaded return(null); } Regex rex = new Regex("S(\\d+)E(\\d+)"); if (Directory.Exists(seriesRoot + "\\EpisodeImages")) { String[] episodeFiles = Directory.GetFiles(seriesRoot + "\\EpisodeImages", "*.jpg"); foreach (String epImageFile in episodeFiles) { try { Match match = rex.Match(epImageFile); int season = Int32.Parse(match.Groups[1].Value); int episode = Int32.Parse(match.Groups[2].Value); foreach (TvdbEpisode e in series.Episodes) { if (e.SeasonNumber == season && e.EpisodeNumber == episode) { e.Banner.LoadBanner(Image.FromFile(epImageFile)); break; } } } catch (Exception) { Log.Warn("Couldn't load episode image file " + epImageFile); } } } #endregion #region Banner loading String bannerFile = seriesRoot + "\\banners.xml"; //load cached banners if (File.Exists(bannerFile)) {//banners have been already loaded List <TvdbBanner> bannerList = m_xmlReader.ExtractBanners(File.ReadAllText(bannerFile)); String[] banners = Directory.GetFiles(seriesRoot, "banner*.jpg"); foreach (String b in banners) { try { int bannerId = Int32.Parse(b.Remove(b.IndexOf(".")).Remove(0, b.LastIndexOf("_") + 1)); foreach (TvdbBanner banner in bannerList) { if (banner.Id == bannerId) { if (b.Contains("thumb") && banner.GetType() == typeof(TvdbFanartBanner)) { ((TvdbFanartBanner)banner).LoadThumb(Image.FromFile(b)); } else if (b.Contains("vignette") && banner.GetType() == typeof(TvdbFanartBanner)) { ((TvdbFanartBanner)banner).LoadVignette(Image.FromFile(b)); } else { banner.LoadBanner(Image.FromFile(b)); } } } } catch (Exception) { Log.Warn("Couldn't load image file " + b); } } series.Banners = bannerList; } #endregion #region actor loading //load actor info String actorFile = seriesRoot + "\\actors.xml"; if (File.Exists(actorFile)) { List <TvdbActor> actorList = m_xmlReader.ExtractActors(File.ReadAllText(actorFile)); String[] banners = Directory.GetFiles(seriesRoot, "actor_*.jpg"); foreach (String b in banners) { try { int actorId = Int32.Parse(b.Remove(b.IndexOf(".")).Remove(0, b.LastIndexOf("_") + 1)); foreach (TvdbActor actor in actorList) { if (actor.Id == actorId) { actor.ActorImage.LoadBanner(Image.FromFile(b)); } } } catch (Exception) { Log.Warn("Couldn't load image file " + b); } } series.TvdbActors = actorList; } #endregion return(series); }
/// <summary> /// Load the give series from cache /// </summary> /// <param name="_seriesId"></param> /// <returns></returns> public TvdbSeries LoadSeriesFromCache(int _seriesId) { String seriesRoot = m_rootFolder + "\\" + _seriesId; String xmlFile = seriesRoot + "\\all.xml"; if (!File.Exists(xmlFile)) { return(null); } String content = File.ReadAllText(xmlFile); List <TvdbSeries> seriesList = m_xmlReader.ExtractSeries(content); if (seriesList != null && seriesList.Count == 1) { TvdbSeries series = seriesList[0]; List <TvdbEpisode> epList = m_xmlReader.ExtractEpisodes(content); series.Episodes = epList; String bannerFile = seriesRoot + "\\banners.xml"; String actorFile = seriesRoot + "\\actors.xml"; Regex rex = new Regex("S(\\d+)E(\\d+)"); if (Directory.Exists(seriesRoot + "\\EpisodeImages")) { String[] episodeFiles = Directory.GetFiles(seriesRoot + "\\EpisodeImages", "*.jpg"); foreach (String epImageFile in episodeFiles) { try { Match match = rex.Match(epImageFile); int season = Int32.Parse(match.Groups[1].Value); int episode = Int32.Parse(match.Groups[2].Value); foreach (TvdbEpisode e in series.Episodes) { if (e.SeasonNumber == season && e.EpisodeNumber == episode) { e.Banner.LoadBanner(Image.FromFile(epImageFile)); break; } } } catch (Exception ex) { Log.Warn("Couldn't load episode image file " + epImageFile); } } } //load cached banners if (File.Exists(bannerFile)) {//banners have been already loaded List <TvdbBanner> bannerList = m_xmlReader.ExtractBanners(File.ReadAllText(bannerFile)); String[] banners = Directory.GetFiles(seriesRoot, "banner*.jpg"); foreach (String b in banners) { try { int bannerId = Int32.Parse(b.Remove(b.IndexOf(".")).Remove(0, b.LastIndexOf("_") + 1)); foreach (TvdbBanner banner in bannerList) { if (banner.Id == bannerId) { if (b.Contains("thumb") && banner.GetType() == typeof(TvdbFanartBanner)) { ((TvdbFanartBanner)banner).LoadThumb(Image.FromFile(b)); } else if (b.Contains("vignette") && banner.GetType() == typeof(TvdbFanartBanner)) { ((TvdbFanartBanner)banner).LoadVignette(Image.FromFile(b)); } else { banner.LoadBanner(Image.FromFile(b)); } } } } catch (Exception) { Log.Warn("Couldn't load image file " + b); } } series.Banners = bannerList; } //load actor info if (File.Exists(actorFile)) { List <TvdbActor> actorList = m_xmlReader.ExtractActors(File.ReadAllText(actorFile)); String[] banners = Directory.GetFiles(seriesRoot, "actor_*.jpg"); foreach (String b in banners) { try { int actorId = Int32.Parse(b.Remove(b.IndexOf(".")).Remove(0, b.LastIndexOf("_") + 1)); foreach (TvdbActor actor in actorList) { if (actor.Id == actorId) { actor.ActorImage.LoadBanner(Image.FromFile(b)); } } } catch (Exception) { Log.Warn("Couldn't load image file " + b); } } series.TvdbActors = actorList; } return(series); } else { return(null); } }
public override async Task <bool> UpdateFromOnlineSeriesAsync(SeriesInfo series, TvdbLanguage language, bool cacheOnly) { try { language = language ?? PreferredLanguage; TvdbSeries seriesDetail = null; if (series.TvdbId > 0) { seriesDetail = await _tvdbHandler.GetSeriesAsync(series.TvdbId, language, true, true, false).ConfigureAwait(false); } if (seriesDetail == null && !cacheOnly && !string.IsNullOrEmpty(series.ImdbId)) { TvdbSearchResult foundSeries = await _tvdbHandler.GetSeriesByRemoteIdAsync(ExternalId.ImdbId, series.ImdbId).ConfigureAwait(false); if (foundSeries != null) { seriesDetail = await _tvdbHandler.GetSeriesAsync(foundSeries.Id, language, true, true, false).ConfigureAwait(false); } } if (seriesDetail == null) { return(false); } series.TvdbId = seriesDetail.Id; series.ImdbId = seriesDetail.ImdbId; series.SeriesName = new SimpleTitle(seriesDetail.SeriesName, false); series.FirstAired = seriesDetail.FirstAired; series.Description = new SimpleTitle(seriesDetail.Overview, false); series.Rating = new SimpleRating(seriesDetail.Rating, seriesDetail.RatingCount); series.Genres = seriesDetail.Genre.Where(s => !string.IsNullOrEmpty(s?.Trim())).Select(s => new GenreInfo { Name = s.Trim() }).ToList(); series.Networks = ConvertToCompanies(seriesDetail.NetworkID, seriesDetail.Network, CompanyAspect.COMPANY_TV_NETWORK); if (seriesDetail.Status.IndexOf("Ended", StringComparison.InvariantCultureIgnoreCase) >= 0) { series.IsEnded = true; } CertificationMapping certification = null; if (CertificationMapper.TryFindMovieCertification(seriesDetail.ContentRating, out certification)) { series.Certification = certification.CertificationId; } series.Actors = ConvertToPersons(seriesDetail.TvdbActors, PersonAspect.OCCUPATION_ACTOR, null, seriesDetail.SeriesName); series.Characters = ConvertToCharacters(seriesDetail.TvdbActors, null, seriesDetail.SeriesName); foreach (TvdbActor actor in seriesDetail.TvdbActors) { _seriesToActorMap.StoreMappedId(actor.Id.ToString(), seriesDetail.Id.ToString()); } foreach (TvdbEpisode episodeDetail in seriesDetail.Episodes.OrderByDescending(e => e.Id)) { SeasonInfo seasonInfo = new SeasonInfo() { TvdbId = episodeDetail.SeasonId, SeriesTvdbId = seriesDetail.Id, SeriesImdbId = seriesDetail.ImdbId, SeriesName = new SimpleTitle(seriesDetail.SeriesName, false), SeasonNumber = episodeDetail.SeasonNumber, DataProviders = new List <string>() { _name } }; if (!series.Seasons.Contains(seasonInfo)) { series.Seasons.Add(seasonInfo); } EpisodeInfo episodeInfo = new EpisodeInfo() { TvdbId = episodeDetail.Id, SeriesTvdbId = seriesDetail.Id, SeriesImdbId = seriesDetail.ImdbId, SeriesName = new SimpleTitle(seriesDetail.SeriesName, false), SeriesFirstAired = seriesDetail.FirstAired, ImdbId = episodeDetail.ImdbId, SeasonNumber = episodeDetail.SeasonNumber, EpisodeNumbers = new List <int>(new int[] { episodeDetail.EpisodeNumber }), FirstAired = episodeDetail.FirstAired, EpisodeName = new SimpleTitle(episodeDetail.EpisodeName, false), Summary = new SimpleTitle(episodeDetail.Overview, false), Genres = seriesDetail.Genre.Where(s => !string.IsNullOrEmpty(s?.Trim())).Select(s => new GenreInfo { Name = s.Trim() }).ToList(), Rating = new SimpleRating(episodeDetail.Rating, episodeDetail.RatingCount), DataProviders = new List <string>() { _name } }; if (episodeDetail.DvdEpisodeNumber > 0) { episodeInfo.DvdEpisodeNumbers = new List <double>(new double[] { episodeDetail.DvdEpisodeNumber }); } episodeInfo.Actors = ConvertToPersons(seriesDetail.TvdbActors, PersonAspect.OCCUPATION_ACTOR, episodeDetail.EpisodeName, seriesDetail.SeriesName); //info.Actors.AddRange(ConvertToPersons(episodeDetail.GuestStars, PersonAspect.OCCUPATION_ACTOR, info.Actors.Count)); episodeInfo.Characters = ConvertToCharacters(seriesDetail.TvdbActors, episodeDetail.EpisodeName, seriesDetail.SeriesName); episodeInfo.Directors = ConvertToPersons(episodeDetail.Directors, PersonAspect.OCCUPATION_DIRECTOR, 0, episodeDetail.EpisodeName, seriesDetail.SeriesName); episodeInfo.Writers = ConvertToPersons(episodeDetail.Writer, PersonAspect.OCCUPATION_WRITER, 0, episodeDetail.EpisodeName, seriesDetail.SeriesName); episodeInfo.Languages.Add(episodeDetail.Language.Abbriviation); if (!series.Episodes.Contains(episodeInfo)) { series.Episodes.Add(episodeInfo); } } series.Episodes.Sort(); series.TotalEpisodes = series.Episodes.Count; for (int index = 0; index < series.Seasons.Count; index++) { series.Seasons[index].FirstAired = series.Episodes.Find(e => e.SeasonNumber == series.Seasons[index].SeasonNumber).FirstAired; series.Seasons[index].TotalEpisodes = series.Episodes.FindAll(e => e.SeasonNumber == series.Seasons[index].SeasonNumber).Count; } series.Seasons.Sort(); series.TotalSeasons = series.Seasons.Count; TvdbEpisode nextEpisode = seriesDetail.Episodes.Where(e => e.FirstAired > DateTime.Now).OrderBy(e => e.FirstAired) .ThenByDescending(p => p.Id).FirstOrDefault(); if (nextEpisode != null) { series.NextEpisodeName = new SimpleTitle(nextEpisode.EpisodeName, false); series.NextEpisodeAirDate = nextEpisode.FirstAired; series.NextEpisodeSeasonNumber = nextEpisode.SeasonNumber; series.NextEpisodeNumber = nextEpisode.EpisodeNumber; } if (!series.DataProviders.Contains(_name)) { series.DataProviders.Add(_name); } return(true); } catch (Exception ex) { ServiceRegistration.Get <ILogger>().Debug("TvDbWrapper: Exception while processing series {0}", ex, series.ToString()); return(false); } }
/// <summary> /// Saves the series to cache /// </summary> /// <param name="_series"></param> public void SaveToCache(TvdbSeries _series) { String root = m_rootFolder + "\\" + _series.Id; m_xmlWriter.WriteSeriesContent(_series, root + "\\all.xml"); if (_series.BannersLoaded) { m_xmlWriter.WriteSeriesBannerContent(_series.Banners, root + "\\banners.xml"); } if (_series.TvdbActorsLoaded) { m_xmlWriter.WriteActorFile(_series.TvdbActors, root + "\\actors.xml"); } //Save all loaded banners to file foreach (TvdbBanner b in _series.Banners) { FileInfo file = new FileInfo(root + "\\banner_" + b.Id + ".jpg"); if (b.IsLoaded && !file.Exists) {//banner is cached if (!file.Directory.Exists) { file.Directory.Create(); } b.Banner.Save(file.FullName); } if (b.GetType() == typeof(TvdbFanartBanner)) {//banner is fanart -> has vignette and thumb file = new FileInfo(root + "\\bannerthumb_" + b.Id + ".jpg"); if (((TvdbFanartBanner)b).IsThumbLoaded && !file.Exists) { if (!file.Directory.Exists) { file.Directory.Create(); } ((TvdbFanartBanner)b).BannerThumb.Save(file.FullName); } file = new FileInfo(root + "\\bannervignette_" + b.Id + ".jpg"); if (((TvdbFanartBanner)b).IsVignetteLoaded && !file.Exists) { if (!file.Directory.Exists) { file.Directory.Create(); } ((TvdbFanartBanner)b).VignetteImage.Save(file.FullName); } } } if (_series.EpisodesLoaded) { foreach (TvdbEpisode e in _series.Episodes) { FileInfo file = new FileInfo(root + "\\EpisodeImages\\S" + e.SeasonNumber + "E" + e.EpisodeNumber + ".jpg"); if (e.Banner.IsLoaded && !file.Exists) { if (!file.Directory.Exists) { file.Directory.Create(); } e.Banner.Banner.Save(file.FullName); } } } if (_series.TvdbActorsLoaded) { foreach (TvdbActor a in _series.TvdbActors) { FileInfo file = new FileInfo(root + "\\actor_" + a.ActorImage.Id + ".jpg"); if (a.ActorImage.IsLoaded && !file.Exists) { if (!file.Directory.Exists) { file.Directory.Create(); } a.ActorImage.Banner.Save(file.FullName); } } } }
public override async Task <bool> UpdateFromOnlineSeriesEpisodeAsync(EpisodeInfo episode, TvdbLanguage language, bool cacheOnly) { try { language = language ?? PreferredLanguage; List <EpisodeInfo> episodeDetails = new List <EpisodeInfo>(); TvdbSeries seriesDetail = null; TvdbEpisode episodeDetail = null; if ((episode.SeriesTvdbId > 0 || !string.IsNullOrEmpty(episode.SeriesImdbId)) && episode.SeasonNumber.HasValue && episode.EpisodeNumbers.Count > 0) { if (episode.SeriesTvdbId > 0) { seriesDetail = await _tvdbHandler.GetSeriesAsync(episode.SeriesTvdbId, language, true, true, true).ConfigureAwait(false); } if (seriesDetail == null && !cacheOnly && !string.IsNullOrEmpty(episode.SeriesImdbId)) { TvdbSearchResult foundSeries = await _tvdbHandler.GetSeriesByRemoteIdAsync(ExternalId.ImdbId, episode.SeriesImdbId).ConfigureAwait(false); if (foundSeries != null) { seriesDetail = await _tvdbHandler.GetSeriesAsync(foundSeries.Id, language, true, true, true).ConfigureAwait(false); } } if (seriesDetail == null) { return(false); } bool isFirstEpisode = true; foreach (int episodeNumber in episode.EpisodeNumbers) { episodeDetail = seriesDetail.Episodes.Where(e => e.EpisodeNumber == episodeNumber && e.SeasonNumber == episode.SeasonNumber.Value).OrderByDescending(e => e.Id).FirstOrDefault(); if (episodeDetail == null) { continue; } EpisodeInfo info = new EpisodeInfo() { TvdbId = episodeDetail.Id, SeriesTvdbId = seriesDetail.Id, SeriesImdbId = seriesDetail.ImdbId, SeriesName = new SimpleTitle(seriesDetail.SeriesName, false), SeriesFirstAired = seriesDetail.FirstAired, ImdbId = episodeDetail.ImdbId, SeasonNumber = episodeDetail.SeasonNumber, EpisodeNumbers = new List <int>(new int[] { episodeDetail.EpisodeNumber }), FirstAired = episodeDetail.FirstAired, EpisodeName = new SimpleTitle(episodeDetail.EpisodeName, false), Summary = new SimpleTitle(episodeDetail.Overview, false), Genres = seriesDetail.Genre.Where(s => !string.IsNullOrEmpty(s?.Trim())).Select(s => new GenreInfo { Name = s.Trim() }).ToList(), Rating = new SimpleRating(episodeDetail.Rating, episodeDetail.RatingCount), DataProviders = new List <string>() { _name } }; if (episodeDetail.DvdEpisodeNumber > 0) { info.DvdEpisodeNumbers = new List <double>(new double[] { episodeDetail.DvdEpisodeNumber }); } info.Actors = ConvertToPersons(seriesDetail.TvdbActors, PersonAspect.OCCUPATION_ACTOR, episodeDetail.EpisodeName, seriesDetail.SeriesName); //info.Actors.AddRange(ConvertToPersons(episodeDetail.GuestStars, PersonAspect.OCCUPATION_ACTOR, info.Actors.Count)); info.Characters = ConvertToCharacters(seriesDetail.TvdbActors, episodeDetail.EpisodeName, seriesDetail.SeriesName); info.Directors = ConvertToPersons(episodeDetail.Directors, PersonAspect.OCCUPATION_DIRECTOR, 0, episodeDetail.EpisodeName, seriesDetail.SeriesName); info.Writers = ConvertToPersons(episodeDetail.Writer, PersonAspect.OCCUPATION_WRITER, 0, episodeDetail.EpisodeName, seriesDetail.SeriesName); info.Languages.Add(episodeDetail.Language.Abbriviation); //Should be handled by the fanart collector instead //if (isFirstEpisode && !episode.HasThumbnail && episodeDetail.Banner != null) // info.Thumbnail = await episodeDetail.Banner.LoadImageDataAsync().ConfigureAwait(false); episodeDetails.Add(info); isFirstEpisode = false; } } if (episodeDetails.Count > 1) { SetMultiEpisodeDetails(episode, episodeDetails); if (!episode.DataProviders.Contains(_name)) { episode.DataProviders.Add(_name); } return(true); } else if (episodeDetails.Count > 0) { SetEpisodeDetails(episode, episodeDetails[0]); if (!episode.DataProviders.Contains(_name)) { episode.DataProviders.Add(_name); } return(true); } return(false); } catch (Exception ex) { ServiceRegistration.Get <ILogger>().Debug("TvDbWrapper: Exception while processing episode {0}", ex, episode.ToString()); return(false); } }
protected bool TryMatch(string seriesNameOrImdbId, bool isImdbId, bool cacheOnly, out TvdbSeries seriesDetail, int tvdbid = 0) { seriesDetail = null; try { // Prefer memory cache CheckCacheAndRefresh(); if (_memoryCache.TryGetValue(seriesNameOrImdbId, out seriesDetail)) { if (tvdbid == 0 || seriesDetail.Id == tvdbid) { return(true); } } // Load cache or create new list List <SeriesMatch> matches; lock (_syncObj) matches = Settings.Load <List <SeriesMatch> >(MatchesSettingsFile) ?? new List <SeriesMatch>(); // Init empty seriesDetail = null; // Use cached values before doing online query SeriesMatch match = matches.Find(m => ( string.Equals(m.ItemName, seriesNameOrImdbId, StringComparison.OrdinalIgnoreCase) || string.Equals(m.TvDBName, seriesNameOrImdbId, StringComparison.OrdinalIgnoreCase) ) && (tvdbid == 0 || m.Id == tvdbid)); ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Try to lookup series \"{0}\" from cache: {1}", seriesNameOrImdbId, match != null && match.Id != 0); // Try online lookup if (!Init()) { return(false); } // If this is a known series, only return the series details (including episodes). if (match != null) { return(match.Id != 0 && _tv.GetSeries(match.Id, true, out seriesDetail)); } if (cacheOnly) { return(false); } TvdbSearchResult matchedSeries = null; bool foundResult = false; if (tvdbid != 0) { foundResult = _tv.GetSeries(tvdbid, true, out seriesDetail); } else if (isImdbId) { // If we got an IMDBID, use it to lookup by key directly _tv.GetSeries(seriesNameOrImdbId, out matchedSeries); } else { // Otherwise we try to find unique series by name List <TvdbSearchResult> series; if (_tv.SearchSeriesUnique(seriesNameOrImdbId, out series)) { matchedSeries = series[0]; } } if (matchedSeries != null) { ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Found unique online match for \"{0}\": \"{1}\" [Lang: {2}]", seriesNameOrImdbId, matchedSeries.SeriesName, matchedSeries.Language); foundResult = _tv.GetSeries(matchedSeries.Id, true, out seriesDetail); } if (foundResult) { ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Loaded details for \"{0}\"", seriesDetail.SeriesName); // Add this match to cache SeriesMatch onlineMatch = new SeriesMatch { ItemName = seriesNameOrImdbId, Id = seriesDetail.Id, TvDBName = seriesDetail.SeriesName }; // Save cache _storage.TryAddMatch(onlineMatch); return(true); } ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: No unique match found for \"{0}\"", seriesNameOrImdbId); // Also save "non matches" to avoid retrying _storage.TryAddMatch(new SeriesMatch { ItemName = seriesNameOrImdbId }); return(false); } catch (Exception ex) { ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Exception while processing series {0}", ex, seriesNameOrImdbId); return(false); } finally { if (seriesDetail != null) { _memoryCache.TryAdd(seriesNameOrImdbId, seriesDetail); } } }
/// <summary> /// Extract all the series fields that are available on thetvdb /// <![CDATA[ /// <?xml version="1.0" encoding="UTF-8" ?> /// <Data> /// <Series> /// <id>73739</id> /// <Actors>|Malcolm David Kelley|Jorge Garcia|Maggie Grace|...|</Actors> /// <Airs_DayOfWeek>Thursday</Airs_DayOfWeek> /// <Airs_Time>9:00 PM</Airs_Time> /// <ContentRating>TV-14</ContentRating> /// <FirstAired>2004-09-22</FirstAired> /// <Genre>|Action and Adventure|Drama|Science-Fiction|</Genre> /// <IMDB_ID>tt0411008</IMDB_ID> /// <Language>en</Language> /// <Network>ABC</Network> /// <Overview>After Oceanic Air flight 815...</Overview> /// <Rating>8.9</Rating> /// <Runtime>60</Runtime> /// <SeriesID>24313</SeriesID> /// <SeriesName>Lost</SeriesName> /// <Status>Continuing</Status> /// <banner>graphical/24313-g2.jpg</banner> /// <fanart>fanart/original/73739-1.jpg</fanart> /// <lastupdated>1205694666</lastupdated> /// <zap2it_id>SH672362</zap2it_id> /// </Series> /// /// </Data> /// ]]> /// </summary> /// <param name="_data"></param> /// <returns></returns> internal List <TvdbSeriesFields> ExtractSeriesFields(String _data) { Stopwatch watch = new Stopwatch(); watch.Start(); XDocument xml = XDocument.Parse(_data); var allSeries = from series in xml.Descendants("Series") select new { Id = series.Element("id").Value, Actors = series.Element("Actors").Value, Airs_DayOfWeek = series.Element("Airs_DayOfWeek").Value, Airs_Time = series.Element("Airs_Time").Value, ContentRating = series.Element("ContentRating").Value, FirstAired = series.Element("FirstAired").Value, Genre = series.Element("Genre").Value, IMDB_ID = series.Element("IMDB_ID").Value, Language = series.Element("Language").Value, Network = series.Element("Network").Value, Overview = series.Element("Overview").Value, Rating = series.Element("Rating").Value, Runtime = series.Element("Runtime").Value, SeriesID = series.Element("SeriesID").Value, SeriesName = series.Element("SeriesName").Value, Status = series.Element("Status").Value, banner = series.Element("banner").Value, fanart = series.Element("fanart").Value, lastupdated = series.Element("lastupdated").Value, zap2it_id = series.Element("zap2it_id").Value }; List <TvdbSeriesFields> retList = new List <TvdbSeriesFields>(); foreach (var s in allSeries) { TvdbSeries series = new TvdbSeries(); series.Id = Util.Int32Parse(s.Id); series.Actors = Util.SplitTvdbString(s.Actors); series.AirsDayOfWeek = Util.GetDayOfWeek(s.Airs_DayOfWeek); series.AirsTime = s.Airs_Time.Equals("") ? new DateTime(1, 1, 1) : DateTime.Parse(s.Airs_Time.Replace(".", ":")); series.ContentRating = s.ContentRating; series.FirstAired = s.FirstAired.Equals("") ? new DateTime() : DateTime.Parse(s.FirstAired); series.Genre = Util.SplitTvdbString(s.Genre); series.ImdbId = s.IMDB_ID; series.Language = Util.ParseLanguage(s.Language); series.Network = s.Network; series.Overview = s.Overview; series.Rating = Util.DoubleParse(s.Rating); series.Runtime = Util.DoubleParse(s.Runtime); series.TvDotComId = Util.Int32Parse(s.SeriesID); series.SeriesName = s.SeriesName; series.Status = s.Status; series.BannerPath = s.banner; series.FanartPath = s.fanart; series.LastUpdated = Util.UnixToDotNet(s.lastupdated); series.Zap2itId = s.zap2it_id; if (series.Id != -99) { retList.Add(series); } } watch.Stop(); Log.Debug("Extracted " + retList.Count + " series in " + watch.ElapsedMilliseconds + " milliseconds"); return(retList); }
/// <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); } }
public void Setup() { WithTempAsAppPath(); series = Builder <Series> .CreateNew() .With(s => s.SeriesId == 79488) .With(s => s.Title == "30 Rock") .Build(); episodeFile = Builder <EpisodeFile> .CreateNew() .With(f => f.SeriesId = 79488) .With(f => f.SeasonNumber = 1) .With(f => f.Path = @"C:\Test\30 Rock\Season 01\30 Rock - S01E01 - Pilot.avi") .Build(); var tvdbEpisodes = Builder <TvdbEpisode> .CreateListOfSize(2) .All() .With(e => e.SeriesId = 79488) .With(e => e.SeasonNumber = 1) .With(e => e.Directors = new List <string> { "Fake Director" }) .With(e => e.Writer = new List <string> { "Fake Writer" }) .With(e => e.GuestStars = new List <string> { "Guest Star 1", "Guest Star 2", "Guest Star 3", "" }) .Build(); var seasonBanners = Builder <TvdbSeasonBanner> .CreateListOfSize(4) .TheFirst(2) .With(b => b.Season = 1) .TheLast(2) .With(b => b.Season = 2) .TheFirst(1) .With(b => b.BannerType = TvdbSeasonBanner.Type.season) .With(b => b.BannerPath = "seasons/79488-1-1.jpg") .TheNext(2) .With(b => b.BannerType = TvdbSeasonBanner.Type.seasonwide) .With(b => b.BannerPath = "banners/seasons/79488-test.jpg") .TheLast(1) .With(b => b.BannerType = TvdbSeasonBanner.Type.season) .With(b => b.BannerPath = "seasons/79488-2-1.jpg") .Build(); var seriesActors = Builder <TvdbActor> .CreateListOfSize(5) .All() .With(a => a.ActorImage = Builder <TvdbActorBanner> .CreateNew().Build()) .Build(); tvdbSeries = Builder <TvdbSeries> .CreateNew() .With(s => s.Id = 79488) .With(s => s.SeriesName = "30 Rock") .With(s => s.TvdbActors = seriesActors.ToList()) .With(s => s.Episodes = tvdbEpisodes.ToList()) .Build(); tvdbSeries.Banners.AddRange(seasonBanners); }
private SeriesTag CopySeriesInfos(SeriesTag seriesTag, TvdbSeries series, int seasonIndex, int episodeIndex) { seriesTag.SeriesName = series.SeriesName; seriesTag.IMDB_ID = series.ImdbId; seriesTag.TVDB_ID = series.Id.ToString(); // Do not overwrite the index //seriesTag.SeasonIndex //seriesTag.EpisodeIndexList seriesTag.Network = series.Network; seriesTag.Certification = series.ContentRating; seriesTag.SeriesFirstAired = series.FirstAired.ToString("yyyy-MM-dd"); seriesTag.SeriesOverview = series.Overview; seriesTag.SeriesGenreList = series.Genre.AsReadOnly(); seriesTag.SeriesActors = series.Actors.AsReadOnly(); TvdbEpisode ep = series.Episodes.FirstOrDefault(e => e.SeasonNumber == seasonIndex && e.EpisodeNumber == episodeIndex); if (ep == null) return seriesTag; seriesTag.EpisodeFirstAired = ep.FirstAired.ToString("yyyy-MM-dd"); seriesTag.EpisodeTitle = ep.EpisodeName; seriesTag.EpisodeIMDB_ID = ep.ImdbId; seriesTag.EpisodeOverview = ep.Overview; seriesTag.GuestStars = ep.GuestStars.AsReadOnly(); seriesTag.Directors = ep.Directors.AsReadOnly(); seriesTag.Writers = ep.Writer.AsReadOnly(); return seriesTag; }
/// <summary> /// Forces a complete update of the series. All information that has already been loaded (including loaded images!) will be deleted and reloaded from tvdb -> if you only want to update the series, use the "MakeUpdate" method /// </summary> /// <param name="_series">Series to reload</param> public TvdbSeries ForceUpdate(TvdbSeries _series) { return(ForceUpdate(_series, _series.EpisodesLoaded, _series.TvdbActorsLoaded, _series.BannersLoaded)); }