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);
}
public string GetNewFilePath(TvdbShow show, TvdbEpisode startEpisode, TvdbEpisode endEpisode, string ext, bool useDvdOrder)
{
var seasonNumber = useDvdOrder ? startEpisode.DvdSeason ?? startEpisode.AiredSeason : startEpisode.AiredSeason;
var startEpisodeNumber = useDvdOrder ? startEpisode.DvdEpisodeNumber ?? startEpisode.AiredEpisodeNumber : startEpisode.AiredEpisodeNumber;
var newFileName = $"{show.SeriesName} - s{seasonNumber.PadLeft(2, '0')}e{startEpisodeNumber.PadLeft(2, '0')}";
if (endEpisode != null)
{
var endEpisodeNumber = useDvdOrder ? endEpisode.DvdEpisodeNumber ?? endEpisode.AiredEpisodeNumber : endEpisode.AiredEpisodeNumber;
newFileName += $"-e{endEpisodeNumber.PadLeft(2, '0')}";
}
newFileName += $" - {startEpisode.EpisodeName}";
if (endEpisode != null)
{
newFileName += $" - {endEpisode.EpisodeName}";
}
newFileName = $"{newFileName}{ext}".CleanFileName();
var showFolder = show.SeriesName.CleanPath();
var seasonFolder = $"Season {seasonNumber}";
return(Path.Combine(showFolder, seasonFolder, newFileName));
}
private void FillEpisodeDetail(TvdbEpisode _episode)
{
lbEpisodeInformation.Text = _episode.EpisodeName + "(" + _episode.EpisodeNumber + ")";
txtEpisodeLanguage.Text = _episode.Language != null?_episode.Language.ToString() : "";
txtEpisodeFirstAired.Text = _episode.FirstAired.ToShortDateString();
lbGuestStars.Items.Clear();
foreach (String s in _episode.GuestStars)
{
lbGuestStars.Items.Add(s.Trim());
}
lbDirectors.Items.Clear();
foreach (String s in _episode.Directors)
{
lbDirectors.Items.Add(s.Trim());
}
lbWriters.Items.Clear();
foreach (String s in _episode.Writer)
{
lbWriters.Items.Add(s.Trim());
}
txtEpisodeProductionCode.Text = _episode.ProductionCode;
txtEpisodeOverview.Text = _episode.Overview;
txtEpisodeDVDId.Text = _episode.DvdDiscId != -99 ? _episode.DvdDiscId.ToString() : "";
txtEpisodeDVDSeason.Text = _episode.DvdSeason != -99 ? _episode.DvdSeason.ToString() : "";
txtEpisodeDVDNumber.Text = _episode.DvdEpisodeNumber != -99 ? _episode.DvdEpisodeNumber.ToString() : "";
txtEpisodeDVDChapter.Text = _episode.DvdChapter != -99 ? _episode.DvdChapter.ToString() : "";
txtEpisodeAbsoluteNumber.Text = _episode.AbsoluteNumber != -99 ? _episode.AbsoluteNumber.ToString() : "";
txtImdbId.Text = _episode.ImdbId;
}
protected bool TryMatchEpisode(SeriesInfo seriesInfo, TvdbSeries seriesDetail)
{
// We deal with two scenarios here:
// - Having a real episode title, but the Season/Episode numbers might be wrong (seldom case)
// - Having only Season/Episode numbers and we need to fill Episode title (more common)
TvdbEpisode episode = seriesDetail.Episodes.Find(e => e.EpisodeName == seriesInfo.Episode);
if (episode != null)
{
seriesInfo.SeasonNumber = episode.SeasonNumber;
seriesInfo.EpisodeNumbers.Clear();
seriesInfo.EpisodeNumbers.Add(episode.EpisodeNumber);
SetEpisodeDetails(seriesInfo, episode);
return(true);
}
episode = seriesDetail.Episodes.Find(e => e.EpisodeNumber == seriesInfo.EpisodeNumbers.FirstOrDefault() && e.SeasonNumber == seriesInfo.SeasonNumber);
if (episode != null)
{
seriesInfo.Episode = episode.EpisodeName;
SetEpisodeDetails(seriesInfo, episode);
return(true);
}
return(false);
}
protected bool Matched(GuideEnricherProgram guideProgram, TvdbEpisode episode)
{
if (guideProgram == null)
{
throw new ArgumentNullException("guideProgram");
}
if (episode == null)
{
throw new ArgumentNullException("episode");
}
//
this.SuccessfulMatches++;
guideProgram.EpisodeNumber = episode.EpisodeNumber;
guideProgram.SeriesNumber = episode.SeasonNumber;
guideProgram.EpisodeNumberDisplay = Enricher.FormatSeasonAndEpisode(episode.SeasonNumber, episode.EpisodeNumber);
if (bool.Parse(Config.Instance.GetProperty("updateSubtitles")))
{
guideProgram.SubTitle = episode.EpisodeName;
}
if (bool.Parse(Config.Instance.GetProperty("episodeInDescription")))
{
var descriptionWithNoEpisodeNumber = Regex.Replace(guideProgram.Description, "^S[0-9][0-9]E[0-9][0-9] - ", string.Empty);
guideProgram.Description = string.Format("{0} - {1}", guideProgram.EpisodeNumberDisplay, descriptionWithNoEpisodeNumber);
}
this.log.DebugFormat("[{0}] Correctly matched {1} - {2} as {3}", this.MethodName, guideProgram.Title, guideProgram.SubTitle, guideProgram.EpisodeNumberDisplay);
return(true);
}
/// <summary>
/// Gets the TVDB representation of this episode.
/// </summary>
/// <returns>The TVDB equivilent of this episode.</returns>
public TvdbEpisode GetTvdbEpisode()
{
// Avoid looking up unknown titles
if (!string.IsNullOrWhiteSpace(TitleVar) || Name == UnknownString || Episode.Count == 0)
{
return(null);
}
// Return previous lookup if already done
if (TvdbEpisode != null)
{
return(TvdbEpisode);
}
// Init API if not done already
if (TvdbApiManager == null)
{
TvdbApiManager = new Tvdb.Tvdb(TvdbApiKey, TvdbCacheType.PersistentMemory,
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "TitleCleaner"));
}
// Search for series
var seriesList = TvdbApiManager.Search(Name);
// No selection required, just assume (unless confirmation is always required)
if (seriesList.Length == 1 && !TvdbLookupConfirm)
{
// Get episode
var seriesId = seriesList[0].TvdbId;
TvdbEpisode = TvdbApiManager.LookupEpisode(seriesId, Season, Episode[0]);
// Return episode
return(TvdbEpisode);
}
if (seriesList.Length <= 1 && (!TvdbLookupConfirm || seriesList.Length <= 0))
{
return(null);
}
// Selection required...
if (TvdbSearchSelectionCache == null)
{
TvdbSearchSelectionCache = new Dictionary <string, uint>();
}
var searchCacheName = Name.ToLower();
Debug.Assert(TvdbSearchSelectionRequired != null, "TvdbSearchSelectionRequired != null");
var id = TvdbSearchSelectionCache.ContainsKey(searchCacheName) ? TvdbSearchSelectionCache[searchCacheName] : TvdbSearchSelectionRequired.Invoke(seriesList, Name);
// Add search selection to cache
if (!TvdbSearchSelectionCache.ContainsKey(searchCacheName))
{
TvdbSearchSelectionCache.Add(searchCacheName, id);
}
// 0 is a sentinal "none of them" value
if (id == 0)
{
return(null);
}
// Get episode
TvdbEpisode = TvdbApiManager.LookupEpisode(id, Season, Episode[0]);
// Return episode
return(TvdbEpisode);
}
private static void SetEpisodeDetails(SeriesInfo seriesInfo, TvdbEpisode episode)
{
seriesInfo.Summary = episode.Overview;
if (episode.Directors.Count > 0)
{
CollectionUtils.AddAll(seriesInfo.Directors, episode.Directors);
}
if (episode.GuestStars.Count > 0)
{
CollectionUtils.AddAll(seriesInfo.Actors, episode.GuestStars);
}
}
public string getTitle(int seriesID, int season, int episode)
{
string newTitle = "";
try
{
if (season > 100)
{
TvdbEpisode e = m_tvdbHandler.GetEpisode(seriesID, new DateTime(episode, season / 100, season % 100), TvdbLanguage.DefaultLanguage);
newTitle = e.EpisodeName;
}
else
{
int seasonScale = season;
int episodeScale = episode;
using (var client = new WebClient())
{
var json = client.DownloadString(String.Format("http://thexem.de/map/all?id={0}&origin=tvdb", seriesID));
RootObject m = JsonConvert.DeserializeObject <RootObject>(json);
foreach (Datum showData in m.data)
{
if (showData.scene.episode == episode && showData.scene.season == season)
{
seasonScale = showData.tvdb.season;
episodeScale = showData.tvdb.episode;
break;
}
}
}
//if (seasonScale == 0 && episodeScale == 0)
// return "";
TvdbSeries s = m_tvdbHandler.GetSeries(seriesID, TvdbLanguage.DefaultLanguage, true, false, false);
foreach (TvdbEpisode esp in s.Episodes)
{
if (seasonScale == esp.SeasonNumber && episodeScale == esp.EpisodeNumber)
{
newTitle = esp.EpisodeName;
break;
}
}
}
}
catch (Exception e)
{
MessageBox.Show(e.Message.ToString());
}
newTitle = newTitle.Replace(":", "").Replace("?", "").Replace("/", "").Replace("<", "").Replace(">", "").Replace("\\", "").Replace("*", "").Replace("|", "").Replace("\"", "");
return(newTitle);
}
/// <summary>
///
/// </summary>
/// <param name="_episodeId"></param>
/// <param name="_language"></param>
/// <returns></returns>
public TvdbEpisode GetEpisode(int _episodeId, TvdbLanguage _language)
{
TvdbEpisode episode = GetEpisodeFromCache(_episodeId, _language);
if (episode != null)
{
return(episode);
}
else
{
episode = m_downloader.DownloadEpisode(_episodeId, _language);
AddEpisodeToCache(episode);
return(episode);
}
}
public string getTitle(int seriesID, int season, int episode)
{
string newTitle = null;
//TvdbEpisode e;
try
{
//if (season > 100) return"";
if (season > 100)
{
TvdbEpisode e = m_tvdbHandler.GetEpisode(seriesID, new DateTime(episode, season / 100, season % 100), TvdbLanguage.DefaultLanguage);
newTitle = e.EpisodeName;
}
else
{
TvdbSeries s = m_tvdbHandler.GetSeries(seriesID, TvdbLanguage.DefaultLanguage, true, false, false);
foreach (TvdbEpisode esp in s.Episodes)
{
if (season == esp.SeasonNumber && episode == esp.EpisodeNumber)
{
newTitle = esp.EpisodeName;
break;
}
}
}
//TvdbSeries s = m_tvdbHandler.GetSeries(seriesID, TvdbLanguage.DefaultLanguage, true, false, false);
////List<string> epList = new List<string>();
//foreach (TvdbEpisode esp in s.Episodes)
//{
// if (season == esp.SeasonNumber && episode == esp.EpisodeNumber)
// {
// newTitle = esp.EpisodeName;
// break;
// }
//}
//newTitle = e.EpisodeName;
}
catch (Exception) { }
if (newTitle == null)
{
return("");
}
newTitle = newTitle.Replace(":", "").Replace("?", "").Replace("/", "").Replace("<", "").Replace(">", "").Replace("\\", "").Replace("*", "").Replace("|", "").Replace("\"", "");
return(newTitle);
}
/// <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="s"></param>
/// <param name="ue"></param>
private void UpdateEpisode(TvdbSeries s, TvdbEpisode ue)
{
List <TvdbEpisode> allEpList = new List <TvdbEpisode>();
allEpList.AddRange(s.Episodes);
foreach (TvdbLanguage l in s.GetAvailableLanguages())
{
if (s.SeriesTranslations[l].Episodes != null && s.SeriesTranslations[l].Language != s.Language)
{
allEpList.AddRange(s.SeriesTranslations[l].Episodes);
}
}
//check all episodes if the updated episode is in it
foreach (TvdbEpisode e in allEpList)
{
if (e.Id == ue.Id)
{
if (e.LastUpdated < ue.LastUpdated)
{
//download episode which has been updated
TvdbEpisode newEpisode = m_downloader.DownloadEpisode(e.Id, e.Language);
//update information of episode with new episodes informations
if (newEpisode != null)
{
newEpisode.LastUpdated = ue.LastUpdated;
e.UpdateEpisodeInfo(newEpisode);
Log.Info("Updated Episode " + e.Id + " for series " + e.SeriesId);
}
}
return;
}
}
//episode hasn't been found
foreach (TvdbLanguage l in s.GetAvailableLanguages())
{
//hasn't been found -> add it
TvdbEpisode ep = m_downloader.DownloadEpisode(ue.Id, l);
AddEpisodeToCache(ep);
Log.Info("Added Episode " + ep.Id + " for series " + ep.SeriesId);
}
}
private void cmdGetEpisodes_Click(object sender, EventArgs e)
{
int sId = Int32.Parse(txtSeriesId2.Text);
int season = Int32.Parse(txtSeason.Text);
int episode = Int32.Parse(txtEpisode.Text);
TvdbEpisode ep = m_tvdbHandler.GetEpisode(sId, season, episode,
(TvdbEpisode.EpisodeOrdering)cbOrdering.SelectedItem,
TvdbLanguage.DefaultLanguage);
lvSeries.Items.Clear();
lvSeries.Items.Add(CreateItem("Series Id", ep.SeriesId.ToString()));
lvSeries.Items.Add(CreateItem("Episode Id", ep.Id.ToString()));
lvSeries.Items.Add(CreateItem("Name", ep.EpisodeName));
lvSeries.Items.Add(CreateItem("Gueststars", ep.GuestStarsString));
lvSeries.Items.Add(CreateItem("Directors", ep.DirectorsString));
lvSeries.Items.Add(CreateItem("Writer", ep.WriterString));
lvSeries.Items.Add(CreateItem("Overview", ep.Overview));
lvSeries.Items.Add(CreateItem("Imdb Id", ep.ImdbId));
}
private static void SetEpisodeDetails(SeriesInfo seriesInfo, TvdbEpisode episode)
{
seriesInfo.TotalRating = episode.Rating;
seriesInfo.Summary = episode.Overview;
// Don't clear seriesInfo.Actors again. It's already been filled with actors from series details.
if (episode.GuestStars.Count > 0)
{
CollectionUtils.AddAll(seriesInfo.Actors, episode.GuestStars);
}
seriesInfo.Directors.Clear();
if (episode.Directors.Count > 0)
{
CollectionUtils.AddAll(seriesInfo.Directors, episode.Directors);
}
seriesInfo.Writers.Clear();
if (episode.Writer.Count > 0)
{
CollectionUtils.AddAll(seriesInfo.Writers, episode.Writer);
}
}
private void cmdGetEpisodeAired_Click(object sender, EventArgs e)
{
TvdbEpisode ep = m_tvdbHandler.GetEpisode(Int32.Parse(txtSeriesEpisodeAiredId.Text), dateTimePickerEpAired.Value, TvdbLanguage.DefaultLanguage);
if (ep != null)
{
lvSeries.Items.Clear();
lvSeries.Items.Add(CreateItem("Series Id", ep.SeriesId.ToString()));
lvSeries.Items.Add(CreateItem("Episode Id", ep.Id.ToString()));
lvSeries.Items.Add(CreateItem("Name", ep.EpisodeName));
lvSeries.Items.Add(CreateItem("Gueststars", ep.GuestStarsString));
lvSeries.Items.Add(CreateItem("Directors", ep.DirectorsString));
lvSeries.Items.Add(CreateItem("Writer", ep.WriterString));
lvSeries.Items.Add(CreateItem("Overview", ep.Overview));
lvSeries.Items.Add(CreateItem("Imdb Id", ep.ImdbId));
}
else
{
MessageBox.Show("Nothing found");
}
}
/// <summary>
///
/// </summary>
/// <param name="_epList"></param>
private void AddEpisodeToCache(TvdbEpisode e)
{
bool seriesFound = false;
foreach (TvdbSeries s in m_loadedData.SeriesList)
{
if (s.Id == e.SeriesId)
{//series for ep found
seriesFound = true;
Util.AddEpisodeToSeries(e, s);
break;
}
}
if (!seriesFound)
{//the series doesn't exist yet -> add episode to dummy series
TvdbSeries newSeries = new TvdbSeries();
newSeries.LastUpdated = new DateTime(1, 1, 1);
newSeries.Episodes.Add(e);
m_loadedData.SeriesList.Add(newSeries);
}
}
/// <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>
/// Add this episode to the proper cached series
/// </summary>
/// <param name="_episode">Episode to add to cache</param>
private void AddEpisodeToCache(TvdbEpisode _episode)
{
bool seriesFound = false;
foreach (TvdbSeries s in m_loadedData.SeriesList)
{
if (s.Id == _episode.SeriesId)
{//series for ep found
seriesFound = true;
Util.AddEpisodeToSeries(_episode, s);
break;
}
}
//todo: maybe skip this since downloading an episode is no biggie
if (!seriesFound)
{//the series doesn't exist yet -> add episode to dummy series
TvdbSeries newSeries = new TvdbSeries();
newSeries.LastUpdated = new DateTime(1, 1, 1);
newSeries.Episodes.Add(_episode);
m_loadedData.SeriesList.Add(newSeries);
}
}
protected async Task <ApiWrapperImageCollection <TvdbBanner> > GetEpisodeFanArtAsync(EpisodeInfo episode, TvdbLanguage language)
{
if (episode == null || (episode.SeriesTvdbId < 1 && string.IsNullOrEmpty(episode.SeriesImdbId)) || !episode.SeasonNumber.HasValue || episode.EpisodeNumbers.Count == 0)
{
return(null);
}
TvdbSeries seriesDetail = null;
if (episode.SeriesTvdbId > 0)
{
seriesDetail = await _tvdbHandler.GetSeriesAsync(episode.SeriesTvdbId, language, true, false, true).ConfigureAwait(false);
}
if (seriesDetail == null && !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, false, true).ConfigureAwait(false);
}
}
if (seriesDetail == null)
{
return(null);
}
TvdbEpisode episodeDetail = seriesDetail.Episodes.Find(e => e.SeasonNumber == episode.SeasonNumber.Value && e.EpisodeNumber == episode.FirstEpisodeNumber);
if (episodeDetail == null)
{
return(null);
}
ApiWrapperImageCollection <TvdbBanner> images = new ApiWrapperImageCollection <TvdbBanner>();
images.Id = episode.TvdbId.ToString();
images.Thumbnails.AddRange(new TvdbBanner[] { episodeDetail.Banner });
return(images);
}
/// <summary>
/// Retrieve the episode with the given parameters
/// </summary>
/// <param name="_seriesId">id of the series</param>
/// <param name="_seasonNr">season number of the episode</param>
/// <param name="_episodeNr">number of the episode</param>
/// <param name="_language">language of the episode</param>
/// <param name="_order">The sorting order that should be user when downloading the episode</param>
/// <returns>The retrieved episode</returns>
public TvdbEpisode GetEpisode(int _seriesId, int _seasonNr, int _episodeNr,
TvdbEpisode.EpisodeOrdering _order, TvdbLanguage _language)
{
String order = null;
switch (_order)
{
case TvdbEpisode.EpisodeOrdering.AbsoluteOrder:
order = "absolut";
break;
case TvdbEpisode.EpisodeOrdering.DefaultOrder:
order = "default";
break;
case TvdbEpisode.EpisodeOrdering.DvdOrder:
order = "dvd";
break;
}
TvdbEpisode episode = m_downloader.DownloadEpisode(_seriesId, _seasonNr, _episodeNr, order, _language);
return(episode);
}
private void tvEpisodes_AfterSelect(object sender, TreeViewEventArgs e)
{
if (tvEpisodes.SelectedNode != null && tvEpisodes.SelectedNode.Tag != null)
{
int selectedSeason = 0;
if (tvEpisodes.SelectedNode.Tag.GetType() == typeof(TvdbEpisode))
{//episode node
TvdbEpisode ep = (TvdbEpisode)tvEpisodes.SelectedNode.Tag;
FillEpisodeDetail(ep);
//load episode image
if (ep.Banner != null)
{
bcEpisodeBanner.BannerImage = ep.Banner;
}
else
{
bcEpisodeBanner.ClearControl();
}
selectedSeason = ep.SeasonNumber;
}
else if (tvEpisodes.SelectedNode.Tag.GetType() == typeof(SeasonTag))
{//season node
SeasonTag tag = (SeasonTag)tvEpisodes.SelectedNode.Tag;
selectedSeason = tag.SeasonNumber;
ClearEpisodeDetail();
lbEpisodeInformation.Text = "Season " + tag.SeasonNumber;
}
else
{//shouldn't happen at all
return;
}
if (bcSeasonBanner.Tag == null || selectedSeason != (int)bcSeasonBanner.Tag)
{
List <TvdbBanner> seasonList = new List <TvdbBanner>();
List <TvdbBanner> seasonWideList = new List <TvdbBanner>();
if (m_currentSeries.SeasonBanners != null && m_currentSeries.SeasonBanners.Count > 0)
{
foreach (TvdbSeasonBanner b in m_currentSeries.SeasonBanners)
{
if (b.Season == selectedSeason)
{
if (b.BannerType == TvdbSeasonBanner.Type.season)
{
if (b.Language == null || b.Language.Abbriviation.Equals(m_currentLanguage.Abbriviation))
{
seasonList.Add(b);
}
}
if (b.BannerType == TvdbSeasonBanner.Type.seasonwide)
{
if (b.Language == null || b.Language.Abbriviation.Equals(m_currentLanguage.Abbriviation))
{
seasonWideList.Add(b);
}
}
}
}
}
if (seasonList.Count > 0)
{
bcSeasonBanner.BannerImages = seasonList;
}
else
{
bcSeasonBanner.ClearControl();
}
bcSeasonBanner.Tag = selectedSeason;
if (seasonWideList.Count > 0)
{
bcSeasonBannerWide.BannerImages = seasonWideList;
}
else
{
bcSeasonBannerWide.ClearControl();
}
bcSeasonBannerWide.Tag = selectedSeason;
}
}
}
/// <summary>
/// Extract a list of episodes from the given data when the data has the following format:
/// <![CDATA[
/// <?xml version="1.0" encoding="UTF-8" ?>
/// <Episode>
/// <id>332179</id>
/// <DVD_chapter></DVD_chapter>
/// <DVD_discid></DVD_discid>
/// <DVD_episodenumber></DVD_episodenumber>
/// <DVD_season></DVD_season>
/// <Director>|Joseph McGinty Nichol|</Director>
/// <EpisodeName>Chuck Versus the World</EpisodeName>
/// <EpisodeNumber>1</EpisodeNumber>
/// <FirstAired>2007-09-24</FirstAired>
/// <GuestStars>|Julia Ling|Vik Sahay|Mieko Hillman|</GuestStars>
/// <IMDB_ID></IMDB_ID>
/// <Language>English</Language>
/// <Overview>Chuck Bartowski is an average computer geek...</Overview>
/// <ProductionCode></ProductionCode>
/// <Rating>9.0</Rating>
/// <SeasonNumber>1</SeasonNumber>
/// <Writer>|Josh Schwartz|Chris Fedak|</Writer>
/// <absolute_number></absolute_number>
/// <airsafter_season></airsafter_season>
/// <airsbefore_episode></airsbefore_episode>
/// <airsbefore_season></airsbefore_season>
/// <filename>episodes/80348-332179.jpg</filename>
/// <lastupdated>1201292806</lastupdated>
/// <seasonid>27985</seasonid>
/// <seriesid>80348</seriesid>
/// </Episode>
/// ]]>
/// </summary>
/// <param name="_data"></param>
/// <returns></returns>
internal List <TvdbEpisode> ExtractEpisodes(String _data)
{
//Stopwatch watch = new Stopwatch();
//watch.Start();
XDocument xml = XDocument.Parse(_data);
var allEpisodes = from episode in xml.Descendants("Episode")
select new
{
Id = episode.Element("id").Value,
Combined_episodenumber = episode.Elements("Combined_episodenumber").Count() == 1
? episode.Element("Combined_episodenumber").Value : "0",
Combined_season = episode.Elements("Combined_season").Count() == 1
? episode.Element("Combined_season").Value : "0",
DVD_chapter = episode.Element("DVD_chapter").Value,
DVD_discid = episode.Element("DVD_discid").Value,
DVD_episodenumber = episode.Element("DVD_episodenumber").Value,
DVD_season = episode.Elements("DVD_season").Count() == 1
? episode.Element("DVD_season").Value : episode.Element("DVD_Season").Value,
Director = episode.Element("Director").Value,
EpisodeName = episode.Element("EpisodeName").Value,
EpisodeNumber = episode.Element("EpisodeNumber").Value,
FirstAired = episode.Element("FirstAired").Value,
GuestStars = episode.Element("GuestStars").Value,
IMDB_ID = episode.Element("IMDB_ID").Value,
Language = episode.Elements("Language").Count() == 1
? episode.Element("Language").Value : "en",
Overview = episode.Element("Overview").Value,
ProductionCode = episode.Element("ProductionCode").Value,
Rating = episode.Element("Rating").Value,
SeasonNumber = episode.Element("SeasonNumber").Value,
Writer = episode.Element("Writer").Value,
absolute_number = episode.Element("absolute_number").Value,
filename = episode.Element("filename").Value,
lastupdated = episode.Element("lastupdated").Value,
seasonid = episode.Element("seasonid").Value,
seriesid = episode.Element("seriesid").Value,
airsafter_season = episode.Elements("airsafter_season").Count() == 1
? episode.Element("airsafter_season").Value : Util.NO_VALUE.ToString(),
airsbefore_episode = episode.Elements("airsbefore_episode").Count() == 1
? episode.Element("airsbefore_episode").Value : Util.NO_VALUE.ToString(),
airsbefore_season = episode.Elements("airsbefore_season").Count() == 1
? episode.Element("airsbefore_season").Value : Util.NO_VALUE.ToString()
};
//Log.Debug("Parsed xml file in " + watch.ElapsedMilliseconds + " milliseconds");
List <TvdbEpisode> retList = new List <TvdbEpisode>();
foreach (var e in allEpisodes)
{
int id = Util.Int32Parse(e.Id);
if (id == Util.NO_VALUE)
{
continue;
}
TvdbEpisode ep = new TvdbEpisode
{
Id = id,
CombinedEpisodeNumber = Util.DoubleParse(e.Combined_episodenumber),
CombinedSeason = Util.DoubleParse(e.Combined_season),
DvdChapter = Util.Int32Parse(e.DVD_chapter),
DvdDiscId = Util.Int32Parse(e.DVD_discid),
DvdEpisodeNumber = Util.DoubleParse(e.DVD_episodenumber),
DvdSeason = Util.Int32Parse(e.DVD_season),
Directors = Util.SplitTvdbString(e.Director, true),
EpisodeName = e.EpisodeName,
EpisodeNumber = Util.Int32Parse(e.EpisodeNumber),
AirsAfterSeason = Util.Int32Parse(e.airsafter_season),
AirsBeforeEpisode = Util.Int32Parse(e.airsbefore_episode),
AirsBeforeSeason = Util.Int32Parse(e.airsbefore_season),
GuestStars = Util.SplitTvdbString(e.GuestStars, true),
ImdbId = e.IMDB_ID,
Language = TvDbUtils.ParseLanguage(e.Language),
Overview = e.Overview,
ProductionCode = e.ProductionCode,
Rating = Util.DoubleParse(e.Rating),
SeasonNumber = Util.Int32Parse(e.SeasonNumber),
Writer = Util.SplitTvdbString(e.Writer, true),
AbsoluteNumber = Util.Int32Parse(e.absolute_number),
BannerPath = e.filename,
LastUpdated = Util.UnixToDotNet(e.lastupdated),
SeasonId = Util.Int32Parse(e.seasonid),
SeriesId = Util.Int32Parse(e.seriesid),
Banner = new TvdbEpisodeBanner(id, e.filename)
};
DateTime firstAired;
ep.FirstAired = DateTime.TryParse(e.FirstAired, out firstAired) ? firstAired : DateTime.MinValue;
retList.Add(ep);
}
//watch.Stop();
//Log.Debug("Extracted " + retList.Count + " Episodes in " + watch.ElapsedMilliseconds + " milliseconds");
return(retList);
}
/// <summary>
/// Extract a list of episodes from the given data when the data has the following format:
/// <![CDATA[
/// <?xml version="1.0" encoding="UTF-8" ?>
/// <Episode>
/// <id>332179</id>
/// <DVD_chapter></DVD_chapter>
/// <DVD_discid></DVD_discid>
/// <DVD_episodenumber></DVD_episodenumber>
/// <DVD_season></DVD_season>
/// <Director>|Joseph McGinty Nichol|</Director>
/// <EpisodeName>Chuck Versus the World</EpisodeName>
/// <EpisodeNumber>1</EpisodeNumber>
/// <FirstAired>2007-09-24</FirstAired>
/// <GuestStars>|Julia Ling|Vik Sahay|Mieko Hillman|</GuestStars>
/// <IMDB_ID></IMDB_ID>
/// <Language>English</Language>
/// <Overview>Chuck Bartowski is an average computer geek...</Overview>
/// <ProductionCode></ProductionCode>
/// <Rating>9.0</Rating>
/// <SeasonNumber>1</SeasonNumber>
/// <Writer>|Josh Schwartz|Chris Fedak|</Writer>
/// <absolute_number></absolute_number>
/// <airsafter_season></airsafter_season>
/// <airsbefore_episode></airsbefore_episode>
/// <airsbefore_season></airsbefore_season>
/// <filename>episodes/80348-332179.jpg</filename>
/// <lastupdated>1201292806</lastupdated>
/// <seasonid>27985</seasonid>
/// <seriesid>80348</seriesid>
/// </Episode>
/// ]]>
/// </summary>
/// <param name="_data"></param>
/// <returns></returns>
internal List <TvdbEpisode> ExtractEpisodes(String _data)
{
//Stopwatch watch = new Stopwatch();
//watch.Start();
XDocument xml = XDocument.Parse(_data);
var allEpisodes = from episode in xml.Descendants("Episode")
select new
{
Id = episode.Element("id").Value,
Combined_episodenumber = episode.Elements("Combined_episodenumber").Count() == 1
? episode.Element("Combined_episodenumber").Value : "0",
Combined_season = episode.Elements("Combined_season").Count() == 1
? episode.Element("Combined_season").Value : "0",
DVD_chapter = episode.Element("DVD_chapter").Value,
DVD_discid = episode.Element("DVD_discid").Value,
DVD_episodenumber = episode.Element("DVD_episodenumber").Value,
DVD_season = episode.Elements("DVD_season").Count() == 1
? episode.Element("DVD_season").Value : episode.Element("DVD_Season").Value,
Director = episode.Element("Director").Value,
EpisodeName = episode.Element("EpisodeName").Value,
EpisodeNumber = episode.Element("EpisodeNumber").Value,
FirstAired = episode.Element("FirstAired").Value,
GuestStars = episode.Element("GuestStars").Value,
IMDB_ID = episode.Element("IMDB_ID").Value,
Language = episode.Elements("Language").Count() == 1
? episode.Element("Language").Value : "en",
Overview = episode.Element("Overview").Value,
ProductionCode = episode.Element("ProductionCode").Value,
Rating = episode.Element("Rating").Value,
SeasonNumber = episode.Element("SeasonNumber").Value,
Writer = episode.Element("Writer").Value,
absolute_number = episode.Element("absolute_number").Value,
filename = episode.Element("filename").Value,
lastupdated = episode.Element("lastupdated").Value,
seasonid = episode.Element("seasonid").Value,
seriesid = episode.Element("seriesid").Value,
airsafter_season = episode.Elements("airsafter_season").Count() == 1
? episode.Element("airsafter_season").Value : "-99",
airsbefore_episode = episode.Elements("airsbefore_episode").Count() == 1
? episode.Element("airsbefore_episode").Value : "-99",
airsbefore_season = episode.Elements("airsbefore_season").Count() == 1
? episode.Element("airsbefore_season").Value : "-99"
};
//Log.Debug("Parsed xml file in " + watch.ElapsedMilliseconds + " milliseconds");
List <TvdbEpisode> retList = new List <TvdbEpisode>();
foreach (var e in allEpisodes)
{
TvdbEpisode ep = new TvdbEpisode();
ep.Id = Util.Int32Parse(e.Id);
ep.CombinedEpisodeNumber = Util.DoubleParse(e.Combined_episodenumber);
ep.CombinedSeason = Util.DoubleParse(e.Combined_season);
ep.DvdChapter = Util.Int32Parse(e.DVD_chapter);
ep.DvdDiscId = Util.Int32Parse(e.DVD_discid);
ep.DvdEpisodeNumber = Util.DoubleParse(e.DVD_episodenumber);
ep.DvdSeason = Util.Int32Parse(e.DVD_season);
ep.Directors = Util.SplitTvdbString(e.Director);
ep.EpisodeName = e.EpisodeName;
ep.EpisodeNumber = Util.Int32Parse(e.EpisodeNumber);
ep.AirsAfterSeason = Util.Int32Parse(e.airsafter_season);
ep.AirsBeforeEpisode = Util.Int32Parse(e.airsbefore_episode);
ep.AirsBeforeSeason = Util.Int32Parse(e.airsbefore_season);
try
{
ep.FirstAired = e.FirstAired.Equals("") ? new DateTime(1, 1, 1) : DateTime.Parse(e.FirstAired);
}
catch (Exception)
{
ep.FirstAired = new DateTime();
}
ep.GuestStars = Util.SplitTvdbString(e.GuestStars);
ep.ImdbId = e.IMDB_ID;
ep.Language = Util.ParseLanguage(e.Language);
ep.Overview = e.Overview;
ep.ProductionCode = e.ProductionCode;
ep.Rating = Util.DoubleParse(e.Rating);
ep.SeasonNumber = Util.Int32Parse(e.SeasonNumber);
ep.Writer = Util.SplitTvdbString(e.Writer);
ep.AbsoluteNumber = Util.Int32Parse(e.absolute_number);
ep.BannerPath = e.filename;
ep.Banner = new TvdbEpisodeBanner(ep.Id, ep.BannerPath);
ep.LastUpdated = Util.UnixToDotNet(e.lastupdated);
ep.SeasonId = Util.Int32Parse(e.seasonid);
ep.SeriesId = Util.Int32Parse(e.seriesid);
if (ep.Id != -99)
{
retList.Add(ep);
}
}
//watch.Stop();
//Log.Debug("Extracted " + retList.Count + " Episodes in " + watch.ElapsedMilliseconds + " milliseconds");
return(retList);
}
/// <summary>
/// Retrieve the episode with the given parameters
/// </summary>
/// <param name="_seriesId">id of the series</param>
/// <param name="_airDate">When did the episode air</param>
/// <param name="_language">language of the episode</param>
/// <exception cref="TvdbInvalidApiKeyException">The given api key is not valid</exception>
/// <returns>The retrieved episode</returns>
public TvdbEpisode GetEpisode(int _seriesId, DateTime _airDate, TvdbLanguage _language)
{
TvdbEpisode ep = m_downloader.DownloadEpisode(_seriesId, _airDate, _language);
return(ep);
}
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),
};
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);
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);
return(true);
}
else if (episodeDetails.Count > 0)
{
SetEpisodeDetails(episode, episodeDetails[0]);
return(true);
}
return(false);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("TvDbWrapper: Exception while processing episode {0}", ex, episode.ToString());
return(false);
}
}
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,
};
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),
};
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;
}
return(true);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("TvDbWrapper: Exception while processing series {0}", ex, series.ToString());
return(false);
}
}
public override bool GetFanArt <T>(T infoObject, TvdbLanguage language, string fanartMediaType, out ApiWrapperImageCollection <TvdbBanner> images)
{
images = new ApiWrapperImageCollection <TvdbBanner>();
try
{
try
{
TvdbSeries seriesDetail = null;
language = language ?? PreferredLanguage;
if (fanartMediaType == FanArtMediaTypes.Series)
{
EpisodeInfo episode = infoObject as EpisodeInfo;
SeasonInfo season = infoObject as SeasonInfo;
SeriesInfo series = infoObject as SeriesInfo;
if (series == null && season != null)
{
series = season.CloneBasicInstance <SeriesInfo>();
}
if (series == null && episode != null)
{
series = episode.CloneBasicInstance <SeriesInfo>();
}
if (series != null && series.TvdbId > 0)
{
seriesDetail = _tvdbHandler.GetSeries(series.TvdbId, language, false, true, true);
if (seriesDetail != null)
{
images.Id = series.TvdbId.ToString();
images.Posters.AddRange(seriesDetail.PosterBanners.OrderBy(b => b.Language != language));
images.Banners.AddRange(seriesDetail.SeriesBanners.OrderBy(b => b.Language != language));
images.Backdrops.AddRange(seriesDetail.FanartBanners.OrderBy(b => b.Language != language));
return(true);
}
}
}
else if (fanartMediaType == FanArtMediaTypes.SeriesSeason)
{
EpisodeInfo episode = infoObject as EpisodeInfo;
SeasonInfo season = infoObject as SeasonInfo;
if (season == null && episode != null)
{
season = episode.CloneBasicInstance <SeasonInfo>();
}
if (season != null && season.SeriesTvdbId > 0 && season.SeasonNumber.HasValue)
{
seriesDetail = _tvdbHandler.GetSeries(season.SeriesTvdbId, language, false, false, true);
if (seriesDetail != null)
{
images.Id = season.TvdbId.ToString();
var seasonLookup = seriesDetail.SeasonBanners.Where(s => s.Season == season.SeasonNumber).ToLookup(s => string.Format("{0}_{1}", s.Season, s.BannerType), v => v);
foreach (IGrouping <string, TvdbSeasonBanner> tvdbSeasonBanners in seasonLookup)
{
images.Banners.AddRange(seasonLookup[tvdbSeasonBanners.Key].Where(b => b.BannerPath.Contains("wide")).OrderBy(b => b.Language != language));
images.Posters.AddRange(seasonLookup[tvdbSeasonBanners.Key].Where(b => !b.BannerPath.Contains("wide")).OrderBy(b => b.Language != language));
}
return(true);
}
}
}
else if (fanartMediaType == FanArtMediaTypes.Episode)
{
EpisodeInfo episode = infoObject as EpisodeInfo;
if (episode != null && episode.SeriesTvdbId > 0 && episode.SeasonNumber.HasValue && episode.EpisodeNumbers.Count > 0)
{
seriesDetail = _tvdbHandler.GetSeries(episode.SeriesTvdbId, language, true, false, true);
if (seriesDetail != null)
{
images.Id = episode.TvdbId.ToString();
TvdbEpisode episodeDetail = seriesDetail.Episodes.Find(e => e.SeasonNumber == episode.SeasonNumber.Value && e.EpisodeNumber == episode.FirstEpisodeNumber);
if (episodeDetail != null)
{
images.Thumbnails.AddRange(new TvdbBanner[] { episodeDetail.Banner });
}
return(true);
}
}
}
else if (fanartMediaType == FanArtMediaTypes.Actor)
{
PersonInfo person = infoObject as PersonInfo;
string seriesId = null;
_seriesToActorMap.GetMappedId(person.TvdbId.ToString(), out seriesId);
int seriesTvdbId = 0;
if (int.TryParse(seriesId, out seriesTvdbId))
{
seriesDetail = _tvdbHandler.GetSeries(seriesTvdbId, language, false, true, true);
if (seriesDetail != null)
{
foreach (TvdbActor actor in seriesDetail.TvdbActors)
{
if (actor.Id == person.TvdbId)
{
images.Id = actor.Id.ToString();
images.Thumbnails.AddRange(new TvdbBanner[] { actor.ActorImage });
return(true);
}
}
}
}
}
else
{
return(true);
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Error("TvDbWrapper: Error getting fan art for scope {0}", ex, fanartMediaType);
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug(GetType().Name + ": Exception downloading images", ex);
}
return(false);
}
