/// <summary>
/// Forces a complete reload of the series. All information that has already been loaded 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>
/// <param name="deleteArtwork">If yes, also deletes previously loaded images</param>
/// <returns>The new TvdbSeries object</returns>
public TvdbSeries ForceReload(TvdbSeries series, bool deleteArtwork)
{
return ForceReload(series, series.EpisodesLoaded, series.TvdbActorsLoaded, series.BannersLoaded, deleteArtwork);
}
/// <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 = _downloader.DownloadSeries(series.Id, kvp.Key, false, false, false);
}
catch (TvdbContentNotFoundException ex)
{//couldn't download the series
Log.Warn("Problem downloading series (id: " + series.Id + "): " + ex);
}
if (newSeries != null)
{//download of the series successfull -> do updating
newSeries.LastUpdated = lastUpdated;
//don't replace episodes, since we're only loading basic series
kvp.Value.UpdateTvdbFields(newSeries, false);
//kvp.Value.Update (newSeries);
Log.Info("Updated Series " + series.SeriesName + " (id: " + series.Id + ", " +
kvp.Key.Abbriviation + ")");
updateDone = true;
}
}
}
series.SetLanguage(currentLanguage);//to copy the episode-fields to the base series
return updateDone;
}
/// <summary>
/// Forces a complete reload 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>
/// <returns>The new TvdbSeries object</returns>
public TvdbSeries ForceReload(TvdbSeries series)
{
return ForceReload(series, series.EpisodesLoaded, series.TvdbActorsLoaded, series.BannersLoaded);
}
/// <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
Log.Debug("Not handling banner " + banner.BannerPath + " because series " + series.Id
+ " doesn't have banners loaded");
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;
b.CacheProvider = _cacheProvider;
b.SeriesId = series.Id;
if (b.IsLoaded)
{//the banner was previously loaded and is updated -> discard the previous image
b.LoadBanner(null);
}
b.UnloadBanner(false);
if (banner.GetType() == typeof(TvdbBannerWithThumb))
{
TvdbBannerWithThumb thumb = (TvdbBannerWithThumb)b;
if (thumb.IsThumbLoaded)
thumb.LoadThumb(null);
thumb.UnloadThumb(false);
}
if (banner.GetType() == typeof(TvdbFanartBanner))
{//update fanart specific content
TvdbFanartBanner fanart = (TvdbFanartBanner)b;
fanart.Resolution = ((TvdbFanartBanner)banner).Resolution;
if (fanart.IsThumbLoaded)
fanart.LoadThumb(null);
fanart.UnloadThumb(false);
if (fanart.IsVignetteLoaded)
fanart.LoadVignette(null);
fanart.UnloadVignette();
}
Log.Info("Replacing banner " + banner.Id);
return true;
}
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;
}
/// <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>
/// <param name="text">Description of the current update</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, out String text)
{
bool updateDone = false;
text = "";
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.Where(e => e.Id == episode.Id))
{
found = true;
if (e.LastUpdated < episode.LastUpdated)
{
//download episode which has been updated
TvdbEpisode newEpisode = null;
try
{
newEpisode = _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;
#region fix for http://forums.thetvdb.com/viewtopic.php?f=8&t=3993
//xml of single episodes doesn't contain CombinedSeason and CombinedEpisodeNumber, so if
//we have values for those, don't override them
//-> http://forums.thetvdb.com/viewtopic.php?f=8&t=3993
//todo: remove this once tvdb fixed that issue
if (e.CombinedSeason != Util.NO_VALUE && newEpisode.CombinedSeason == 0)
{
newEpisode.CombinedSeason = e.CombinedSeason;
}
if (e.CombinedEpisodeNumber != Util.NO_VALUE && newEpisode.CombinedEpisodeNumber == 0)
{
newEpisode.CombinedEpisodeNumber = e.CombinedEpisodeNumber;
}
#endregion
e.UpdateEpisodeInfo(newEpisode);
e.Banner.CacheProvider = _cacheProvider;
e.Banner.SeriesId = series.Id;
e.Banner.UnloadBanner(false);
e.Banner.UnloadThumb(false);
text = "Added/Updated episode " + series.SeriesName + " " + e.SeasonNumber +
"x" + e.EpisodeNumber + "(id: " + e.Id + ")";
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 = _downloader.DownloadEpisode(episode.Id, kvp.Key);
}
catch (TvdbContentNotFoundException ex)
{
Log.Warn("Problem downloading " + episode.Id + ": " + ex);
}
if (ep != null)
{
kvp.Value.Episodes.Add(ep);
//sort the episodes according to default (aired) order
kvp.Value.Episodes.Sort(new EpisodeComparerAired());
text = "Added/Updated episode " + series.SeriesName + " " + ep.SeasonNumber +
"x" + ep.EpisodeNumber + "(id: " + ep.Id + ")";
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 handling episode " + episode.Id + ", because series " + series.SeriesName + " hasn't loaded episodes");
updateDone = false;
}
}
series.SetLanguage(currentLanguage);
return updateDone;
}
/// <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>
/// <exception cref="TvdbInvalidXmlException"><para>Exception is thrown when there was an error parsing the xml files. </para>
/// <para>Feel free to post a detailed description of this issue on http://code.google.com/p/tvdblib
/// or http://forums.thetvdb.com/</para></exception>
/// <exception cref="TvdbUserNotFoundException">The user doesn't exist</exception>
/// <exception cref="TvdbNotAvailableException">The tvdb database is unavailable</exception>
public List<int> AddSeriesToFavorites(TvdbSeries series)
{
return series == null ? null : AddSeriesToFavorites(series.Id);
}
/// <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();
#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
return series;
}
/// <summary>
/// Uptdate the info of the current series with the updated one
/// </summary>
/// <param name="series">TvdbSeries object</param>
protected void UpdateSeriesInfo(TvdbSeries series)
{
Actors = series.Actors;
AirsDayOfWeek = series.AirsDayOfWeek;
AirsTime = series.AirsTime;
BannerPath = series.BannerPath;
Banners = series.Banners;
ContentRating = series.ContentRating;
FanartPath = series.FanartPath;
FirstAired = series.FirstAired;
Genre = series.Genre;
Id = series.Id;
ImdbId = series.ImdbId;
Language = series.Language;
LastUpdated = series.LastUpdated;
Network = series.Network;
Overview = series.Overview;
Rating = series.Rating;
Runtime = series.Runtime;
SeriesName = series.SeriesName;
Status = series.Status;
TvDotComId = series.TvDotComId;
Zap2itId = series.Zap2itId;
if (series.EpisodesLoaded)
{//check if the old series has any images loaded already -> if yes, save them
if (EpisodesLoaded)
{
foreach (TvdbEpisode oe in 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;
}
}
}
}
Episodes.Clear();
Episodes.AddRange(series.Episodes);
}
if (series.TvdbActorsLoaded)
{//check if the old series has any images loaded already -> if yes, save them
if (TvdbActorsLoaded)
{
foreach (TvdbActor oa in TvdbActors)
{
foreach (TvdbActor na in series.TvdbActors)
{
if (oa.Id == na.Id)
if (oa.ActorImage != null && oa.ActorImage.IsLoaded)
na.ActorImage = oa.ActorImage;
}
}
}
TvdbActors = series.TvdbActors;
}
if (series.BannersLoaded)
{
//check if the old series has any images loaded already -> if yes, save them
if (BannersLoaded)
{
foreach (TvdbBanner ob in 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;
}
}
}
}
}
Banners = series.Banners;
}
}
/// <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;
}
}
/// <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 (!string.IsNullOrEmpty(series.BannerPath))
series.Banners.Add(new TvdbSeriesBanner(series.Id, series.BannerPath, series.Language,
TvdbSeriesBanner.Type.Graphical));
if (!string.IsNullOrEmpty(series.FanartPath))
series.Banners.Add(new TvdbFanartBanner(series.Id, series.FanartPath, series.Language));
if (!string.IsNullOrEmpty(series.PosterPath))
series.Banners.Add(new TvdbPosterBanner(series.Id, series.PosterPath, series.Language));
retList.Add(series);
}
return retList;
}
/// <summary>
/// Saves the series to cache
/// </summary>
/// <param name="series">Tvdb series</param>
public void SaveToCache(TvdbSeries series)
{
if (series != null)
{
String seriesRoot = _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
_filestream = new FileStream(seriesRoot + Path.DirectorySeparatorChar + "series_" + series.Id + ".ser", FileMode.Create);
_formatter.Serialize(_filestream, series);
_filestream.Close();
//serialize series config to hdd
SeriesConfiguration cfg = new SeriesConfiguration(series.Id, series.EpisodesLoaded,
series.BannersLoaded, series.TvdbActorsLoaded);
_filestream = new FileStream(seriesRoot + Path.DirectorySeparatorChar + "series_" + series.Id + ".cfg", FileMode.Create);
_formatter.Serialize(_filestream, cfg);
_filestream.Close();
}
}
/// <summary>
/// Uptdate the info of the current series with the updated one
/// </summary>
/// <param name="series">TvdbSeries object</param>
protected void UpdateSeriesInfo(TvdbSeries series)
{
Actors = series.Actors;
AirsDayOfWeek = series.AirsDayOfWeek;
AirsTime = series.AirsTime;
BannerPath = series.BannerPath;
Banners = series.Banners;
ContentRating = series.ContentRating;
FanartPath = series.FanartPath;
FirstAired = series.FirstAired;
Genre = series.Genre;
Id = series.Id;
ImdbId = series.ImdbId;
Language = series.Language;
LastUpdated = series.LastUpdated;
Network = series.Network;
Overview = series.Overview;
Rating = series.Rating;
Runtime = series.Runtime;
SeriesName = series.SeriesName;
Status = series.Status;
TvDotComId = series.TvDotComId;
Zap2itId = series.Zap2itId;
if (series.EpisodesLoaded)
{//check if the old series has any images loaded already -> if yes, save them
if (EpisodesLoaded)
{
foreach (TvdbEpisode oe in 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;
}
}
}
}
}
Episodes.Clear();
Episodes.AddRange(series.Episodes);
}
if (series.TvdbActorsLoaded)
{//check if the old series has any images loaded already -> if yes, save them
if (TvdbActorsLoaded)
{
foreach (TvdbActor oa in TvdbActors)
{
foreach (TvdbActor na in series.TvdbActors)
{
if (oa.Id == na.Id)
{
if (oa.ActorImage != null && oa.ActorImage.IsLoaded)
{
na.ActorImage = oa.ActorImage;
}
}
}
}
}
TvdbActors = series.TvdbActors;
}
if (series.BannersLoaded)
{
//check if the old series has any images loaded already -> if yes, save them
if (BannersLoaded)
{
foreach (TvdbBanner ob in 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;
}
}
}
}
}
}
Banners = series.Banners;
}
}
/// <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 ?? ""),
new XElement("fanart", series.FanartPath ?? ""),
new XElement("Poster", series.PosterPath ?? ""),
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 != Util.NO_VALUE ? e.DvdChapter.ToString() : ""),
new XElement("DVD_discid", e.DvdDiscId != Util.NO_VALUE ? e.DvdDiscId.ToString() : ""),
new XElement("DVD_episodenumber", e.DvdEpisodeNumber != Util.NO_VALUE ? e.DvdEpisodeNumber.ToString() : ""),
new XElement("DVD_season", e.DvdSeason != Util.NO_VALUE ? 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 != Util.NO_VALUE ? e.AirsAfterSeason.ToString() : ""),
new XElement("airsbefore_episode", e.AirsBeforeEpisode != Util.NO_VALUE ? e.AirsBeforeEpisode.ToString() : ""),
new XElement("airsbefore_season", e.AirsBeforeSeason != Util.NO_VALUE ? 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>
/// Forces a complete reload 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>The new TvdbSeries object</returns>
public TvdbSeries ForceReload(TvdbSeries series, bool loadEpisodes,
bool loadActors, bool loadBanners)
{
return ForceReload(series, loadEpisodes, loadActors, loadBanners, 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>
/// Forces a complete reload of the series. All information that has already been loaded 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>
/// <param name="replaceArtwork">If yes, also deletes previously loaded images</param>
/// <returns>The new TvdbSeries object</returns>
public TvdbSeries ForceReload(TvdbSeries series, bool loadEpisodes, bool loadActors, bool loadBanners, bool replaceArtwork)
{
if (series == null)
{
Log.Warn("no series given (null)");
return null;
}
TvdbSeries newSeries = _downloader.DownloadSeries(series.Id, series.Language, loadEpisodes, loadActors, loadBanners);
if (newSeries == null)
{
Log.Warn("Couldn't load series " + series.Id + ", reloading not successful");
return null;
}
if (_cacheProvider != null && _cacheProvider.Initialised)
{
//remove old series from cache and store the reloaded one
if (replaceArtwork)
_cacheProvider.RemoveFromCache(series.Id); //removes all info (including images)
_cacheProvider.SaveToCache(newSeries);
}
return newSeries;
}
/// <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;
}
/// <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>
/// <exception cref="TvdbInvalidXmlException"><para>Exception is thrown when there was an error parsing the xml files. </para>
/// <para>Feel free to post a detailed description of this issue on http://code.google.com/p/tvdblib
/// or http://forums.thetvdb.com/</para></exception>
/// <exception cref="TvdbUserNotFoundException">The user doesn't exist</exception>
/// <exception cref="TvdbNotAvailableException">The tvdb database is unavailable</exception>
public List<int> RemoveSeriesFromFavorites(TvdbSeries series)
{
return RemoveSeriesFromFavorites(series.Id);
}
/// <summary>
/// Saves the series to cache
/// </summary>
/// <param name="series">The series to save</param>
public void SaveToCache(TvdbSeries series)
{
String root = _rootFolder + Path.DirectorySeparatorChar + series.Id;
if (!Directory.Exists(root)) Directory.CreateDirectory(root);
try
{
//delete old cached content
String[] files = Directory.GetFiles(root, "*.xml");
foreach (String f in files)
{
File.Delete(f);
}
}
catch (Exception ex)
{
Log.Warn("Couldn't delete old cache files", ex);
}
foreach (KeyValuePair<TvdbLanguage, TvdbSeriesFields> kvp in series.SeriesTranslations)
{
//write all languages to file
String fName = root + Path.DirectorySeparatorChar + kvp.Key.Abbriviation +
(kvp.Value.EpisodesLoaded ? "_full" : "") + ".xml";
_xmlWriter.WriteSeriesContent(new TvdbSeries(kvp.Value), fName);
}
if (series.BannersLoaded)
{
//write the banners file
_xmlWriter.WriteSeriesBannerContent(series.Banners, root + Path.DirectorySeparatorChar + "banners.xml");
}
if (series.TvdbActorsLoaded)
{
//write the actors file
_xmlWriter.WriteActorFile(series.TvdbActors, root + Path.DirectorySeparatorChar + "actors.xml");
}
}
