public static int AddBasicInfo(TvdbSeries series)
{
// Get Series Id
var seriesId = SeriesEntity.GetId(series.Id, series.SeriesName);
// Add Series Metadata
StatusEnum? status;
try
{
status = (StatusEnum)Enum.Parse(typeof(StatusEnum), series.Status);
}
catch (Exception e)
{
Logger.ErrorException("Error while converting status string to enum.", e);
status = null;
}
SeriesEntity.AddMetadata(
seriesId,
series.ImdbId,
series.Zap2itId,
series.Network,
series.ContentRating,
Convert.ToDecimal(series.Rating),
status,
GetAirTime(series.AirsDayOfWeek, series.AirsTime),
series.FirstAired,
Convert.ToInt16(Math.Round(series.Runtime, 0)),
DateTime.UtcNow);
Logger.Trace("Genres: {0}", series.GenreString);
AddGenres(seriesId, series.Genre);
return seriesId;
}
public void DebugEpisodeDump(TvdbSeries tvdbSeries)
{
if (config.GetProperty("dumpepisodes").ToUpper() == "TRUE")
{
this.DumpSeriesEpisodes(tvdbSeries);
}
}
public void AddSeries(string path, TvdbSeries series)
{
Logger.Info("Adding Series [{0}]:{1} Path: {2}", series.Id, series.SeriesName, path);
var repoSeries = new Series();
repoSeries.SeriesId = series.Id;
repoSeries.Title = series.SeriesName;
repoSeries.AirTimes = series.AirsTime;
repoSeries.AirsDayOfWeek = series.AirsDayOfWeek;
repoSeries.Overview = series.Overview;
repoSeries.Status = series.Status;
repoSeries.Language = series.Language != null ? series.Language.Abbriviation : string.Empty;
repoSeries.Path = path;
repoSeries.CleanTitle = CleanUpRegex.Replace(series.SeriesName, "").ToLower();
_sonioRepo.Add(repoSeries);
}
private void cmdInit_Click(object sender, EventArgs e)
{
m_tvdbHandler = new TvdbHandler(new XmlCacheProvider("C:\\test"), Resources.API_KEY);
m_series = m_tvdbHandler.GetBasicSeries(80370, TvdbLanguage.DefaultLanguage, true);
int count = 0;
fanartControl1.NumberOfImages = m_series.FanartBanners.Count;
foreach (TvdbFanartBanner fb in m_series.FanartBanners)
{
if(fb.IsThumbLoaded || fb.LoadThumb())
{
fanartControl1.SetImage(fb, count);
count++;
}
}
}
private void cmdLoadBannerTest_Click(object sender, EventArgs e)
{
m_selectedSeriesForBannerTesting = m_tvdbHandler.GetSeries(Int32.Parse(txtSeriesIdForBanners.Text), TvdbLanguage.DefaultLanguage, true, true, true, true);
if (m_selectedSeriesForBannerTesting != null)
{
m_bannerTestingIndex = 0;
pbBannerTesting.Visible = true;
pbBannerTesting.BringToFront();
LoadBanner(m_bannerTestingIndex);
}
else
{
MessageBox.Show("Couldn't load series");
}
}
public void Setup()
{
WithTempAsAppPath();
series = Builder<Series>
.CreateNew()
.With(s => s.SeriesId == 79488)
.With(s => s.Title == "30 Rock")
.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())
.Build();
tvdbSeries.Banners.AddRange(seasonBanners);
}
public void EnrichProgram(GuideEnricherProgram existingProgram, TvdbSeries tvdbSeries)
{
if (existingProgram == null) throw new ArgumentNullException("existingProgram");
if (tvdbSeries == null) throw new ArgumentNullException("tvdbSeries");
//
log.DebugFormat("Starting lookup for {0} - {1}", existingProgram.Title, existingProgram.SubTitle);
foreach (var matchMethod in this.matchMethods)
{
try
{
if (matchMethod.Match(existingProgram, tvdbSeries.Episodes))
{
existingProgram.Matched = true;
break;
}
}
catch (Exception e)
{
log.ErrorFormat("Matchmethod \"{0}\" failed with exception \"{1}\"", matchMethod.MethodName, e.GetBaseException().Message, e);
}
}
}
/// <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 update</param>
/// <param name="_loadEpisodes">Should episodes be loaded as well</param>
/// <param name="_loadActors">Should actors be loaded as well</param>
/// <param name="_loadBanners">Should banners be loaded as well</param>
/// <returns></returns>
public TvdbSeries ForceUpdate(TvdbSeries _series, bool _loadEpisodes,
bool _loadActors, bool _loadBanners)
{
if (_series != null)
{
TvdbSeries newSeries = m_downloader.DownloadSeries(_series.Id, _series.Language, _loadEpisodes,
_loadActors, _loadBanners);
if (newSeries != null)
{
if (m_cacheProvider != null && m_cacheProvider.Initialised)
{//remove old series from cache and store the reloaded one
m_cacheProvider.RemoveFromCache(_series.Id);
m_cacheProvider.SaveToCache(newSeries);
}
return newSeries;
}
else
{
Log.Warn("Couldn't load series " + _series.Id + ", reloading not successful");
return null;
}
}
else
{
Log.Warn("no series given (null)");
return null;
}
}
/// <summary>
/// Adds the series to the users list of favorites and returns the new list of
/// favorites
/// </summary>
/// <param name="_series">series to add to the favorites</param>
/// <returns>new list with all favorites</returns>
public List<int> AddSeriesToFavorites(TvdbSeries _series)
{
if (_series == null) return null;
return AddSeriesToFavorites(_series.Id);
}
/// <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);
}
/// <summary>
/// Update the series with the episode (Add it to the series if it doesn't already exist or update the episode if the current episode is older than the updated one)
/// </summary>
/// <param name="_series">Series of the updating episode</param>
/// <param name="_episode">Episode that is updated</param>
/// <param name="_progress">Progress of the update run</param>
/// <returns>true if episode has been updated, false if not (e.g. timestamp of updated episode older than
/// timestamp of existing episode</returns>
private bool UpdateEpisode(TvdbSeries _series, TvdbEpisode _episode, int _progress)
{
bool updateDone = false;
TvdbLanguage currentLanguage = _series.Language;
foreach (KeyValuePair<TvdbLanguage, TvdbSeriesFields> kvp in _series.SeriesTranslations)
{
if (_series.EpisodesLoaded)
{
bool found = false;
List<TvdbEpisode> eps = kvp.Value.Episodes;
if (eps != null && eps.Count > 0)
{
//check all episodes if the updated episode is in it
foreach (TvdbEpisode e in eps)
{
if (e.Id == _episode.Id)
{
found = true;
if (e.LastUpdated < _episode.LastUpdated)
{
//download episode which has been updated
TvdbEpisode newEpisode = null;
try
{
newEpisode = m_downloader.DownloadEpisode(e.Id, kvp.Key);
}
catch (TvdbContentNotFoundException)
{
Log.Warn("Couldn't download episode " + e.Id + "(" + e.EpisodeName + ")");
}
//update information of episode with new episodes informations
if (newEpisode != null)
{
newEpisode.LastUpdated = _episode.LastUpdated;
e.UpdateEpisodeInfo(newEpisode);
if (UpdateProgressed != null)
{//update has started, we're downloading the updated content from tvdb
UpdateProgressed(new UpdateProgressEventArgs(UpdateProgressEventArgs.UpdateStage.episodesupdate,
"Updating episode " + _series.SeriesName + " " + e.SeasonNumber +
"x" + e.EpisodeNumber + "(id: " + _episode.Id + ")",
_progress, 50 + (int)(_progress / 4)));
}
Log.Info("Updated Episode " + e.SeasonNumber + "x" + e.EpisodeNumber + " for series " + _series.SeriesName +
"(id: " + e.Id + ", lang: " + e.Language.Abbriviation + ")");
updateDone = true;
}
}
break;
}
}
}
if (!found)
{
//episode hasn't been found
//hasn't been found -> add it to series
TvdbEpisode ep = null;
try
{
ep = m_downloader.DownloadEpisode(_episode.Id, kvp.Key);
}
catch (TvdbContentNotFoundException ex)
{
Log.Warn("Problem downloading " + _episode.Id + ": " + ex.ToString());
}
if (ep != null)
{
kvp.Value.Episodes.Add(ep);
//todo: sort here!!!! -> create episode comparer
//kvp.Value.Episodes.Sort(new Comparison<TvdbEpisode>(v
if (UpdateProgressed != null)
{//update has started, we're downloading the updated content from tvdb
UpdateProgressed(new UpdateProgressEventArgs(UpdateProgressEventArgs.UpdateStage.episodesupdate,
"Added episode " + _series.SeriesName + " " + ep.SeasonNumber +
"x" + ep.EpisodeNumber + "(id: " + ep.Id + ")",
_progress, 50 + (int)(_progress / 4)));
}
Log.Info("Added Episode " + ep.SeasonNumber + "x" + ep.EpisodeNumber + " for series " + _series.SeriesName +
"(id: " + ep.Id + ", lang: " + ep.Language.Abbriviation + ")");
updateDone = true;
}
}
}
else
{
Log.Debug("Not adding episode " + _episode.Id + ", because series " + _series.SeriesName + " hasn't loaded episodes");
updateDone = false;
}
}
_series.SetLanguage(currentLanguage);
return updateDone;
}
/// <summary>
/// Download the new series and update the information
/// </summary>
/// <param name="_series">Series to update</param>
/// <param name="_lastUpdated">When was the last update made</param>
/// <param name="_progress">The progress done until now</param>
/// <returns>true if the series has been upated false if not</returns>
private bool UpdateSeries(TvdbSeries _series, DateTime _lastUpdated, int _progress)
{
//get series info
bool updateDone = false;
TvdbLanguage currentLanguage = _series.Language;
foreach (KeyValuePair<TvdbLanguage, TvdbSeriesFields> kvp in _series.SeriesTranslations)
{
if (kvp.Value.LastUpdated < _lastUpdated)
{//the local content is older than the update time in the updates xml files
TvdbSeries newSeries = null;
try
{//try to get the series
newSeries = GetSeries(_series.Id, kvp.Key, false, false, false);
}
catch (TvdbContentNotFoundException ex)
{//couldn't download the series
Log.Warn("Problem downloading series (id: " + _series.Id + "): " + ex.ToString());
}
if (newSeries != null)
{//download of the series successfull -> do updating
if (UpdateProgressed != null)
{//update has started, we're downloading the updated content from tvdb
UpdateProgressed(new UpdateProgressEventArgs(UpdateProgressEventArgs.UpdateStage.seriesupdate,
"Updating series " + _series.SeriesName,
_progress, 25 + (int)(_progress / 4)));
}
newSeries.LastUpdated = _lastUpdated;
//don't replace episodes, since they're
kvp.Value.UpdateTvdbFields(newSeries, false);
//kvp.Value.Update (newSeries);
Log.Info("Updated Series " + _series.SeriesName + " (id: " + _series.Id + ")");
updateDone = true;
}
}
}
_series.SetLanguage(currentLanguage);//to copy the episode-fields to the base series
return updateDone;
}
/// <summary>
/// Add the episode to the series
/// </summary>
/// <param name="_episode"></param>
/// <param name="_series"></param>
internal static void AddEpisodeToSeries(TvdbEpisode _episode, TvdbSeries _series)
{
bool episodeFound = false; ;
for (int i = 0; i < _series.Episodes.Count; i++)
{
if (_series.Episodes[i].Id == _episode.Id)
{//we have already stored this episode -> overwrite it
_series.Episodes[i].UpdateEpisodeInfo(_episode);
episodeFound = true;
break;
}
}
if (!episodeFound)
{//the episode doesn't exist yet
_series.Episodes.Add(_episode);
if (!_series.EpisodesLoaded) _series.EpisodesLoaded = true;
}
}
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();
}
if (_series.PosterBanners.Count > 0)
{
posterControlSeries.PosterImages = _series.PosterBanners;
}
else
{
posterControlSeries.ClearPoster();
}
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;
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 : 0;
}
public virtual void CreateForEpisodeFile(EpisodeFile episodeFile, TvdbSeries tvDbSeries)
{
foreach (var provider in _metadataProviders.Where(i => GetSettings(i.GetType()).Enable))
{
provider.CreateForEpisodeFile(episodeFile, tvDbSeries);
}
}
/// <summary>
/// Extract a list of series in the format:
/// <![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<TvdbSeries> ExtractSeries(String _data)
{
List<TvdbSeriesFields> tvdbInfo = ExtractSeriesFields(_data);
List<TvdbSeries> retList = new List<TvdbSeries>();
foreach (TvdbSeriesFields s in tvdbInfo)
{
TvdbSeries series = new TvdbSeries(s);
if (!series.BannerPath.Equals(""))
{
series.Banners.Add(new TvdbSeriesBanner(series.Id, series.BannerPath, series.Language, TvdbSeriesBanner.Type.graphical));
}
if (!series.FanartPath.Equals(""))
{
series.Banners.Add(new TvdbFanartBanner(series.Id, series.FanartPath, series.Language));
}
if (!series.PosterPath.Equals(""))
{
series.Banners.Add(new TvdbPosterBanner(series.Id, series.PosterPath, series.Language));
}
retList.Add(series);
}
return retList;
}
public TVShowMetadata(IFileSystem fileSystem, DirectoryInfoBase cacheDirectory, TvdbSeries tvdbSeries, TvdbEpisode tvdbEpisode)
{
// Set metadata.
TVShowName = tvdbSeries.SeriesName;
SeasonNumber = tvdbEpisode.SeasonNumber;
EpisodeNumber = tvdbEpisode.EpisodeNumber;
Name = tvdbEpisode.EpisodeName;
Description = tvdbEpisode.Overview;
Genres = tvdbSeries.Genre;
Cast = tvdbSeries.Actors;
Directors = tvdbEpisode.Directors;
Screenwriters = tvdbEpisode.Writer;
ReleaseDate = tvdbEpisode.FirstAired;
Network = tvdbSeries.Network;
// Get artwork.
if (SeasonNumber.HasValue && tvdbSeries.SeasonBanners.Any(banner => banner.Season == SeasonNumber))
{
Artwork = tvdbSeries.SeasonBanners.Where (banner => banner.Season == SeasonNumber).FirstOrDefault ().GetBannerCacheFile (fileSystem, cacheDirectory, false).ToBase64Image();
}
else if(tvdbSeries.PosterBanners.Any())
{
Artwork = tvdbSeries.PosterBanners.FirstOrDefault ().GetBannerCacheFile (fileSystem, cacheDirectory, false).ToBase64Image();
}
else if(tvdbSeries.SeriesBanners.Any())
{
Artwork = tvdbSeries.SeriesBanners.FirstOrDefault ().GetBannerCacheFile (fileSystem, cacheDirectory, false).ToBase64Image();
}
}
private void DumpSeriesEpisodes(TvdbSeries series)
{
this.log.InfoFormat("Dumping episode info for {0}", series.SeriesName);
foreach (var episode in series.Episodes)
{
this.log.InfoFormat("S{0:00}E{1:00}-{2}", episode.SeasonNumber, episode.EpisodeNumber, episode.EpisodeName);
}
}
private void UpdateSeries(TvdbSeries _series)
{
m_currentSeries = _series;
FillSeriesDetails(_series);
cmdForceUpdate.Enabled = true;
if (_series.BannersLoaded)
{
cmdLoadBanners.Enabled = false;
pnlFanartEnabled.Visible = false;
}
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>
/// Write the series content to file
/// </summary>
/// <param name="_series">Series to store</param>
/// <param name="_path">Path on disk</param>
/// <returns>true if the file could be stored, false otherwise</returns>
internal bool WriteSeriesContent(TvdbSeries _series, String _path)
{
String fileContent = CreateSeriesContent(_series);
try
{
FileInfo info = new FileInfo(_path);
if (!info.Directory.Exists) info.Directory.Create();
File.WriteAllText(info.FullName, fileContent);
return true;
}
catch (Exception)
{
return false;
}
}
/// <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.Abbriviation),
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>
/// 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);
}
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 (!_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)
{
_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
{
_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);
}
}
}
/// <summary>
/// Uptdate the info of the current series with the updated one
/// </summary>
/// <param name="_series">TvdbSeries object</param>
protected void UpdateSeriesInfo(TvdbSeries _series)
{
this.Actors = _series.Actors;
this.AirsDayOfWeek = _series.AirsDayOfWeek;
this.AirsTime = _series.AirsTime;
this.BannerPath = _series.BannerPath;
this.Banners = _series.Banners;
this.ContentRating = _series.ContentRating;
this.FanartPath = _series.FanartPath;
this.FirstAired = _series.FirstAired;
this.Genre = _series.Genre;
this.Id = _series.Id;
this.ImdbId = _series.ImdbId;
this.Language = _series.Language;
this.LastUpdated = _series.LastUpdated;
this.Network = _series.Network;
this.Overview = _series.Overview;
this.Rating = _series.Rating;
this.Runtime = _series.Runtime;
this.SeriesName = _series.SeriesName;
this.Status = _series.Status;
this.TvDotComId = _series.TvDotComId;
this.Zap2itId = _series.Zap2itId;
if (_series.EpisodesLoaded)
{//check if the old series has any images loaded already -> if yes, save them
if (this.EpisodesLoaded)
{
foreach (TvdbEpisode oe in this.Episodes)
{
foreach (TvdbEpisode ne in _series.Episodes)
{
if (oe.SeasonNumber == ne.SeasonNumber &&
oe.EpisodeNumber == ne.EpisodeNumber)
{
if (oe.Banner != null && oe.Banner.IsLoaded)
{
ne.Banner = oe.Banner;
}
}
}
}
}
this.Episodes.Clear();
this.Episodes.AddRange(_series.Episodes);
}
if (_series.TvdbActorsLoaded)
{//check if the old series has any images loaded already -> if yes, save them
if (this.TvdbActorsLoaded)
{
foreach (TvdbActor oa in this.TvdbActors)
{
foreach (TvdbActor na in _series.TvdbActors)
{
if (oa.Id == na.Id)
{
if (oa.ActorImage != null && oa.ActorImage.IsLoaded)
{
na.ActorImage = oa.ActorImage;
}
}
}
}
}
this.TvdbActors = _series.TvdbActors;
}
if (_series.BannersLoaded)
{
//check if the old series has any images loaded already -> if yes, save them
if (this.BannersLoaded)
{
foreach (TvdbBanner ob in this.Banners)
{
foreach (TvdbBanner nb in _series.Banners)
{
if (ob.BannerPath.Equals(nb.BannerPath))//I have to check for the banner path since the Update file doesn't include IDs
{
if (ob.BannerImage != null && ob.IsLoaded)
{
nb.BannerImage = ob.BannerImage;
}
if (ob.GetType() == typeof(TvdbFanartBanner))
{
TvdbFanartBanner newFaBanner = (TvdbFanartBanner)nb;
TvdbFanartBanner oldFaBanner = (TvdbFanartBanner)ob;
if (oldFaBanner.ThumbImage != null && oldFaBanner.IsThumbLoaded)
{
newFaBanner.ThumbImage = oldFaBanner.ThumbImage;
}
if (oldFaBanner.ThumbImage != null && oldFaBanner.IsVignetteLoaded)
{
newFaBanner.VignetteImage = oldFaBanner.VignetteImage;
}
}
}
}
}
}
this.Banners = _series.Banners;
}
}
/// <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();
}
}
public virtual void CreateForSeries(Series series, TvdbSeries tvDbSeries)
{
foreach (var provider in _metadataProviders.Where(i => GetSettings(i.GetType()).Enable))
{
provider.CreateForSeries(series, tvDbSeries);
}
}
/// <summary>
/// Uptdate the info of the current series with the updated one
/// </summary>
/// <param name="_series"></param>
public void UpdateSeriesInfo(TvdbSeries _series)
{
this.Actors = _series.Actors;
this.AirsDayOfWeek = _series.AirsDayOfWeek;
this.AirsTime = _series.AirsTime;
this.BannerPath = _series.BannerPath;
this.Banners = _series.Banners;
this.ContentRating = _series.ContentRating;
this.FanartPath = _series.FanartPath;
this.FirstAired = _series.FirstAired;
this.Genre = _series.Genre;
this.Id = _series.Id;
this.ImdbId = _series.ImdbId;
this.Language = _series.Language;
this.LastUpdated = _series.LastUpdated;
this.Network = _series.Network;
this.Overview = _series.Overview;
this.Rating = _series.Rating;
this.Runtime = _series.Runtime;
this.SeriesName = _series.SeriesName;
this.Status = _series.Status;
this.TvDotComId = _series.TvDotComId;
this.Zap2itId = _series.Zap2itId;
if (_series.EpisodesLoaded)
{//check if the old series has any images loaded already -> if yes, save them
if (this.EpisodesLoaded)
{
foreach (TvdbEpisode oe in this.Episodes)
{
foreach (TvdbEpisode ne in _series.Episodes)
{
if (oe.SeasonNumber == ne.SeasonNumber &&
oe.EpisodeNumber == ne.EpisodeNumber)
{
if (oe.Banner != null && oe.Banner.IsLoaded)
{
ne.Banner = oe.Banner;
}
}
}
}
}
this.Episodes = _series.Episodes;
}
if (_series.TvdbActorsLoaded)
{//check if the old series has any images loaded already -> if yes, save them
if (this.TvdbActorsLoaded)
{
foreach (TvdbActor oa in this.TvdbActors)
{
foreach (TvdbActor na in _series.TvdbActors)
{
if (oa.Id == na.Id)
{
if (oa.ActorImage != null && oa.ActorImage.IsLoaded)
{
na.ActorImage = oa.ActorImage;
}
}
}
}
}
this.TvdbActors = _series.TvdbActors;
}
if (_series.BannersLoaded)
{
//check if the old series has any images loaded already -> if yes, save them
if (this.BannersLoaded)
{
foreach (TvdbBanner ob in this.Banners)
{
foreach (TvdbBanner nb in _series.Banners)
{
if (ob.BannerPath.Equals(nb.BannerPath))//I have to check for the banner path since the Update file doesn't include IDs
{
if (ob.BannerImage != null && ob.IsLoaded)
{
nb.BannerImage = ob.BannerImage;
}
if (ob.GetType() == typeof(TvdbFanartBanner))
{
TvdbFanartBanner newFaBanner = (TvdbFanartBanner)nb;
TvdbFanartBanner oldFaBanner = (TvdbFanartBanner)ob;
if (oldFaBanner.ThumbImage != null && oldFaBanner.IsThumbLoaded)
{
newFaBanner.ThumbImage = oldFaBanner.ThumbImage;
}
if (oldFaBanner.ThumbImage != null && oldFaBanner.IsVignetteLoaded)
{
newFaBanner.VignetteImage = oldFaBanner.VignetteImage;
}
}
}
}
}
}
this.Banners = _series.Banners;
}
}
private void DownloadSeasonThumbnails(Series series, TvdbSeries tvDbSeries, TvdbSeasonBanner.Type bannerType)
{
var seasons = tvDbSeries.SeasonBanners.Where(s => s.BannerType == bannerType).Select(s => s.Season);
foreach (var season in seasons)
{
var banner = tvDbSeries.SeasonBanners.FirstOrDefault(b => b.BannerType == bannerType && b.Season == season);
_logger.Debug("Downloading banner for Season: {0} Series: {1}", season, series.Title);
if (season == 0)
{
if (!_diskProvider.FileExists(Path.Combine(series.Path, "season-specials.tbn")))
{
_bannerProvider.Download(banner.BannerPath,
Path.Combine(series.Path, "season-specials.tbn"));
}
}
else
{
if (!_diskProvider.FileExists(Path.Combine(series.Path, String.Format("season{0:00}.tbn", season))))
{
_bannerProvider.Download(banner.BannerPath,
Path.Combine(series.Path, String.Format("season{0:00}.tbn", season)));
}
}
}
}
private TvdbSeries GetTvdbSeries(int seriesId, TvdbSeries tvdbSeries, bool forceRefresh)
{
try
{
tvdbSeries = this.tvDbService.GetSeries(seriesId, this.language, true, false, false);
if (forceRefresh)
{
tvdbSeries = this.tvDbService.ForceReload(tvdbSeries, true, false, false);
}
}
catch (TvdbException tvdbException)
{
this.log.Debug("TVDB Error getting series", tvdbException);
}
return tvdbSeries;
}
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");
return;
}
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>
/// Update the series with the banner
/// </summary>
/// <param name="_series"></param>
/// <param name="_banner"></param>
/// <returns>true, if the banner was updated successfully, false otherwise</returns>
private bool UpdateBanner(TvdbSeries _series, TvdbBanner _banner)
{
if (!_series.BannersLoaded)
{//banners for this series havn't been loaded -> don't update banners
return false;
}
foreach (TvdbBanner b in _series.Banners)
{
if (_banner.GetType() == b.GetType() && _banner.BannerPath.Equals(b.BannerPath))
{//banner was found
if (b.LastUpdated < _banner.LastUpdated)
{//update time of local banner is longer ago than update time of current update
b.LastUpdated = _banner.LastUpdated;
if (_banner.GetType() == typeof(TvdbFanartBanner))
{//update fanart specific content
TvdbFanartBanner fanart = (TvdbFanartBanner)b;
fanart.Resolution = ((TvdbFanartBanner)_banner).Resolution;
if (fanart.IsThumbLoaded)
{
fanart.LoadThumb(null);
}
if (fanart.IsVignetteLoaded)
{
fanart.LoadVignette(null);
}
}
if (b.IsLoaded)
{//the banner was previously loaded and is updated -> discard the previous image
b.LoadBanner(null);
b.UnloadBanner(false);
}
Log.Info("Replacing banner " + _banner.Id);
return true;
}
else
{
Log.Debug("Not replacing banner " + _banner.Id + " because it's not newer than current image");
return false;
}
}
}
//banner not found -> add it to bannerlist
Log.Info("Adding banner " + _banner.Id);
_series.Banners.Add(_banner);
return true;
}
