private void cmdLoadByImdbId_Click(object sender, EventArgs e)
{
if (!txtImdbSearchId.Text.Equals(""))
{
TvdbSearchResult result = m_tvdbHandler.GetSeriesByRemoteId(ExternalId.ImdbId, txtImdbSearchId.Text);
if (result != null)
{
List <TvdbSearchResult> list = new List <TvdbSearchResult>();
list.Add(result);
SearchResultForm form = new SearchResultForm(list);
form.StartPosition = FormStartPosition.Manual;
form.Left = this.Left + this.Width / 2 - form.Width / 2;
form.Top = this.Top + this.Height / 2 - form.Height / 2;
DialogResult res = form.ShowDialog();
if (res == DialogResult.OK)
{
LoadSeries(form.Selection.Id);
}
}
else
{
MessageBox.Show("No results for this series");
}
}
}
public override async Task <bool> UpdateFromOnlineSeriesPersonAsync(SeriesInfo seriesInfo, PersonInfo person, TvdbLanguage language, bool cacheOnly)
{
try
{
if (person.Occupation != PersonAspect.OCCUPATION_ACTOR)
{
return(false);
}
language = language ?? PreferredLanguage;
TvdbSeries seriesDetail = null;
if (seriesInfo.TvdbId > 0)
{
seriesDetail = await _tvdbHandler.GetSeriesAsync(seriesInfo.TvdbId, language, true, true, false).ConfigureAwait(false);
}
if (seriesDetail == null && !cacheOnly && !string.IsNullOrEmpty(seriesInfo.ImdbId))
{
TvdbSearchResult foundSeries = await _tvdbHandler.GetSeriesByRemoteIdAsync(ExternalId.ImdbId, seriesInfo.ImdbId).ConfigureAwait(false);
if (foundSeries != null)
{
seriesDetail = await _tvdbHandler.GetSeriesAsync(foundSeries.Id, language, true, true, false).ConfigureAwait(false);
}
}
if (seriesDetail == null)
{
return(false);
}
List <PersonInfo> actors = ConvertToPersons(seriesDetail.TvdbActors, PersonAspect.OCCUPATION_ACTOR, null, seriesDetail.SeriesName);
int index = actors.IndexOf(person);
if (index >= 0)
{
person.TvdbId = actors[index].TvdbId;
person.Name = actors[index].Name;
person.Occupation = actors[index].Occupation;
person.Order = actors[index].Order;
person.ParentMediaName = seriesDetail.SeriesName;
if (!person.DataProviders.Contains(_name))
{
person.DataProviders.Add(_name);
}
return(true);
}
return(false);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("TvDbWrapper: Exception while processing person {0}", ex, person.ToString());
return(false);
}
}
public override async Task <bool> UpdateFromOnlineSeriesSeasonAsync(SeasonInfo season, TvdbLanguage language, bool cacheOnly)
{
try
{
language = language ?? PreferredLanguage;
TvdbSeries seriesDetail = null;
if (season.SeriesTvdbId > 0)
{
seriesDetail = await _tvdbHandler.GetSeriesAsync(season.SeriesTvdbId, language, true, false, false).ConfigureAwait(false);
}
if (seriesDetail == null && !cacheOnly && !string.IsNullOrEmpty(season.SeriesImdbId))
{
TvdbSearchResult foundSeries = await _tvdbHandler.GetSeriesByRemoteIdAsync(ExternalId.ImdbId, season.SeriesImdbId).ConfigureAwait(false);
if (foundSeries != null)
{
seriesDetail = await _tvdbHandler.GetSeriesAsync(foundSeries.Id, language, true, false, false).ConfigureAwait(false);
}
}
if (seriesDetail == null)
{
return(false);
}
if (!season.SeasonNumber.HasValue)
{
return(false);
}
var episode = seriesDetail.Episodes.Where(e => e.SeasonNumber == season.SeasonNumber).ToList().FirstOrDefault();
if (episode == null)
{
return(false);
}
season.TvdbId = episode.SeasonId;
season.SeriesTvdbId = seriesDetail.Id;
season.SeriesImdbId = seriesDetail.ImdbId;
season.FirstAired = episode.FirstAired;
season.SeriesName = new SimpleTitle(seriesDetail.SeriesName, false);
season.SeasonNumber = season.SeasonNumber.Value;
season.Description = new SimpleTitle(seriesDetail.Overview, false);
season.TotalEpisodes = seriesDetail.Episodes.FindAll(e => e.SeasonNumber == season.SeasonNumber).Count;
if (!season.DataProviders.Contains(_name))
{
season.DataProviders.Add(_name);
}
return(true);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("TvDbWrapper: Exception while processing season {0}", ex, season.ToString());
return(false);
}
}
public override async Task <bool> UpdateFromOnlineSeriesCompanyAsync(SeriesInfo seriesInfo, CompanyInfo company, TvdbLanguage language, bool cacheOnly)
{
try
{
if (company.Type != CompanyAspect.COMPANY_TV_NETWORK)
{
return(false);
}
language = language ?? PreferredLanguage;
TvdbSeries seriesDetail = null;
if (seriesInfo.TvdbId > 0)
{
seriesDetail = await _tvdbHandler.GetSeriesAsync(seriesInfo.TvdbId, language, true, false, false).ConfigureAwait(false);
}
if (seriesDetail == null && !cacheOnly && !string.IsNullOrEmpty(seriesInfo.ImdbId))
{
TvdbSearchResult foundSeries = await _tvdbHandler.GetSeriesByRemoteIdAsync(ExternalId.ImdbId, seriesInfo.ImdbId).ConfigureAwait(false);
if (foundSeries != null)
{
seriesDetail = await _tvdbHandler.GetSeriesAsync(foundSeries.Id, language, true, false, false).ConfigureAwait(false);
}
}
if (seriesDetail == null)
{
return(false);
}
List <CompanyInfo> companies = ConvertToCompanies(seriesDetail.NetworkID, seriesDetail.Network, CompanyAspect.COMPANY_TV_NETWORK);
int index = companies.IndexOf(company);
if (index >= 0)
{
company.TvdbId = companies[index].TvdbId;
company.Name = companies[index].Name;
company.Type = companies[index].Type;
company.Order = companies[index].Order;
if (!company.DataProviders.Contains(_name))
{
company.DataProviders.Add(_name);
}
return(true);
}
return(false);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("TvDbWrapper: Exception while processing company {0}", ex, company.ToString());
return(false);
}
}
private void OKButton_Click(object sender, RoutedEventArgs e)
{
if (ResultsTabControl.SelectedIndex == 0 && MovieResultList.SelectedIndex > -1)
{
MovieDBSelectionResult = (SearchMovie)MovieResultList.SelectedItem;
}
if (ResultsTabControl.SelectedIndex == 1 && ShowResultList.SelectedIndex > -1)
{
TvdbSelectionResult = (TvdbSearchResult)ShowResultList.SelectedItem;
}
DialogResult = true;
}
public override async Task <bool> UpdateFromOnlineSeriesCharacterAsync(SeriesInfo seriesInfo, CharacterInfo character, TvdbLanguage language, bool cacheOnly)
{
try
{
language = language ?? PreferredLanguage;
TvdbSeries seriesDetail = null;
if (seriesInfo.TvdbId > 0)
{
seriesDetail = await _tvdbHandler.GetSeriesAsync(seriesInfo.TvdbId, language, true, true, false).ConfigureAwait(false);
}
if (seriesDetail == null && !cacheOnly && !string.IsNullOrEmpty(seriesInfo.ImdbId))
{
TvdbSearchResult foundSeries = await _tvdbHandler.GetSeriesByRemoteIdAsync(ExternalId.ImdbId, seriesInfo.ImdbId).ConfigureAwait(false);
if (foundSeries != null)
{
seriesDetail = await _tvdbHandler.GetSeriesAsync(foundSeries.Id, language, true, true, false).ConfigureAwait(false);
}
}
if (seriesDetail == null)
{
return(false);
}
List <CharacterInfo> characters = ConvertToCharacters(seriesDetail.TvdbActors, null, seriesDetail.SeriesName);
int index = characters.IndexOf(character);
if (index >= 0)
{
character.ActorTvdbId = characters[index].ActorTvdbId;
character.ActorName = characters[index].ActorName;
character.Name = characters[index].Name;
character.Order = characters[index].Order;
character.ParentMediaName = seriesDetail.SeriesName;
if (!character.DataProviders.Contains(_name))
{
character.DataProviders.Add(_name);
}
return(true);
}
return(false);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("TvDbWrapper: Exception while processing character {0}", ex, character.ToString());
return(false);
}
}
/// <summary>
/// Extract the results of a series search with format:
/// <![CDATA[
/// <?xml version="1.0" encoding="UTF-8" ?>
/// <Data>
/// <Series>
/// <seriesid>73739</seriesid>
/// <language>en</language>
/// <SeriesName>Lost</SeriesName>
/// <banner>graphical/24313-g2.jpg</banner>
/// <Overview>After Oceanic Air flight 815...</Overview>
/// <FirstAired>2004-09-22</FirstAired>
/// <IMDB_ID>tt0411008</IMDB_ID>
/// <zap2it_id>SH672362</zap2it_id>
/// <id>73739</id>
/// </Series>
/// </Data>
/// ]]>
/// </summary>
/// <param name="_data"></param>
/// <returns></returns>
internal List <TvdbSearchResult> ExtractSeriesSearchResults(String _data)
{
XDocument xml = XDocument.Parse(_data);
var allSeries = from series in xml.Descendants("Series")
where series.HasElements == true
select new
{
Id = Util.Int32Parse(series.Element("seriesid").Value),
FirstAired = series.Element("FirstAired") != null?series.Element("FirstAired").Value : "",
Language = series.Element("language") != null?series.Element("language").Value : "",
Overview = series.Element("Overview") != null?series.Element("Overview").Value : "",
SeriesName = series.Element("SeriesName") != null?series.Element("SeriesName").Value : "",
IMDB_ID = series.Element("IMDB_ID") != null?series.Element("IMDB_ID").Value : "",
BannerPath = series.Element("banner") != null?series.Element("banner").Value : "",
AliasNames = series.Element("AliasNames") != null?Util.SplitTvdbString(series.Element("AliasNames").Value) : new List <string>(0)
};
List <TvdbSearchResult> retList = new List <TvdbSearchResult>();
foreach (var s in allSeries)
{
TvdbSearchResult res = new TvdbSearchResult();
res.Id = s.Id;
res.ImdbId = s.IMDB_ID;
if (!s.FirstAired.Equals(""))
{
res.FirstAired = DateTime.Parse(s.FirstAired);
}
if (!s.Language.Equals(""))
{
res.Language = Util.ParseLanguage(s.Language);
}
res.SeriesName = s.SeriesName;
res.Overview = s.Overview;
res.AliasNames = s.AliasNames;
if (!s.BannerPath.Equals(""))
{
res.Banner = new TvdbSeriesBanner(0, s.BannerPath, null, TvdbSeriesBanner.Type.none);
}
else
{
res.Banner = new TvdbSeriesBanner(s.Id, null, null, TvdbSeriesBanner.Type.none);
}
retList.Add(res);
}
return(retList);
}
private void lvSearchResult_SelectedIndexChanged(object sender, EventArgs e)
{
if (lvSearchResult.SelectedItems.Count == 1)
{
m_selection = (TvdbSearchResult)lvSearchResult.SelectedItems[0].Tag;
bcSeriesBanner.ClearControl();
if (m_selection != null)
{
bcSeriesBanner.BannerImage = m_selection.Banner;
}
txtOverview.Text = m_selection.Overview;
linkImdb.Text = m_selection.ImdbId.Equals("")? "": "http://www.imdb.com/title/" + m_selection.ImdbId;
txtFirstAired.Text = m_selection.FirstAired.ToShortDateString();
}
}
/// <summary>
/// Extract the results of a series search with format:
/// <![CDATA[
/// <?xml version="1.0" encoding="UTF-8" ?>
/// <Data>
/// <Series>
/// <seriesid>73739</seriesid>
/// <language>en</language>
/// <SeriesName>Lost</SeriesName>
/// <banner>graphical/24313-g2.jpg</banner>
/// <Overview>After Oceanic Air flight 815...</Overview>
/// <FirstAired>2004-09-22</FirstAired>
/// <IMDB_ID>tt0411008</IMDB_ID>
/// <zap2it_id>SH672362</zap2it_id>
/// <id>73739</id>
/// </Series>
/// </Data>
/// ]]>
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
internal List <TvdbSearchResult> ExtractSeriesSearchResults(String data)
{
XDocument xml = XDocument.Parse(data);
var allSeries = from series in xml.Descendants("Series")
where series.HasElements
select new
{
Id = Util.Int32Parse(series.Element("seriesid").Value),
FirstAired = series.Element("FirstAired") != null?series.Element("FirstAired").Value : "",
Language = series.Element("language") != null?series.Element("language").Value : "",
Overview = series.Element("Overview") != null?series.Element("Overview").Value : "",
SeriesName = series.Element("SeriesName") != null?series.Element("SeriesName").Value : "",
IMDB_ID = series.Element("IMDB_ID") != null?series.Element("IMDB_ID").Value : "",
BannerPath = series.Element("banner") != null?series.Element("banner").Value : ""
};
List <TvdbSearchResult> retList = new List <TvdbSearchResult>();
foreach (var s in allSeries)
{
TvdbSearchResult res = new TvdbSearchResult {
Id = s.Id, ImdbId = s.IMDB_ID
};
if (!s.FirstAired.Equals(""))
{
res.FirstAired = DateTime.Parse(s.FirstAired, System.Globalization.CultureInfo.InvariantCulture);
}
if (!s.Language.Equals(""))
{
res.Language = TvDbUtils.ParseLanguage(s.Language);
}
res.SeriesName = s.SeriesName;
res.Overview = s.Overview;
res.Banner = !s.BannerPath.Equals("") ?
new TvdbSeriesBanner(0, s.BannerPath, null, TvdbSeriesBanner.Type.None) :
new TvdbSeriesBanner(s.Id, null, null, TvdbSeriesBanner.Type.None);
retList.Add(res);
}
return(retList);
}
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);
}
protected async Task <ApiWrapperImageCollection <TvdbBanner> > GetSeasonFanArtAsync(SeasonInfo season, TvdbLanguage language)
{
if (season == null || (season.SeriesTvdbId < 1 && string.IsNullOrEmpty(season.SeriesImdbId)) || !season.SeasonNumber.HasValue)
{
return(null);
}
TvdbSeries seriesDetail = null;
if (season.SeriesTvdbId > 0)
{
seriesDetail = await _tvdbHandler.GetSeriesAsync(season.SeriesTvdbId, language, false, false, true).ConfigureAwait(false);
}
if (seriesDetail == null && !string.IsNullOrEmpty(season.SeriesImdbId))
{
TvdbSearchResult foundSeries = await _tvdbHandler.GetSeriesByRemoteIdAsync(ExternalId.ImdbId, season.SeriesImdbId).ConfigureAwait(false);
if (foundSeries != null)
{
seriesDetail = await _tvdbHandler.GetSeriesAsync(foundSeries.Id, language, false, false, true).ConfigureAwait(false);
}
}
if (seriesDetail == null)
{
return(null);
}
ApiWrapperImageCollection <TvdbBanner> images = new ApiWrapperImageCollection <TvdbBanner>();
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(images);
}
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 async Task <List <EpisodeInfo> > SearchSeriesEpisodeAsync(EpisodeInfo episodeSearch, TvdbLanguage language)
{
language = language ?? PreferredLanguage;
SeriesInfo seriesSearch = episodeSearch.CloneBasicInstance <SeriesInfo>();
if (episodeSearch.SeriesTvdbId <= 0 && string.IsNullOrEmpty(episodeSearch.SeriesImdbId))
{
if (!await SearchSeriesUniqueAndUpdateAsync(seriesSearch, language).ConfigureAwait(false))
{
return(null);
}
episodeSearch.CopyIdsFrom(seriesSearch);
}
List <EpisodeInfo> episodes = null;
if ((episodeSearch.SeriesTvdbId > 0 || !string.IsNullOrEmpty(episodeSearch.SeriesImdbId)) && episodeSearch.SeasonNumber.HasValue)
{
int seriesId = 0;
if (episodeSearch.SeriesTvdbId > 0)
{
seriesId = episodeSearch.SeriesTvdbId;
}
else if (!string.IsNullOrEmpty(episodeSearch.SeriesImdbId))
{
TvdbSearchResult searchResult = await _tvdbHandler.GetSeriesByRemoteIdAsync(ExternalId.ImdbId, episodeSearch.SeriesImdbId);
if (searchResult?.Id > 0)
{
seriesId = searchResult.Id;
}
}
TvdbSeries seriesDetail = await _tvdbHandler.GetSeriesAsync(seriesId, language, true, false, false).ConfigureAwait(false);
if (seriesDetail == null)
{
return(null);
}
foreach (TvdbEpisode episode in seriesDetail.Episodes.OrderByDescending(e => e.Id))
{
if ((episodeSearch.EpisodeNumbers.Contains(episode.EpisodeNumber) || episodeSearch.EpisodeNumbers.Count == 0) &&
(episodeSearch.SeasonNumber == episode.SeasonNumber || episodeSearch.SeasonNumber.HasValue == false))
{
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
}
EpisodeInfo info = new EpisodeInfo
{
TvdbId = episode.Id,
SeriesName = new SimpleTitle(seriesDetail.SeriesName, false),
SeasonNumber = episode.SeasonNumber,
EpisodeName = new SimpleTitle(episode.EpisodeName, false),
};
info.EpisodeNumbers.Add(episode.EpisodeNumber);
info.CopyIdsFrom(seriesSearch);
info.Languages.Add(episode.Language.Abbriviation);
if (!episodes.Contains(info))
{
episodes.Add(info);
}
}
}
if (episodes != null)
{
episodes.Sort();
}
}
if (episodes == null)
{
episodes = new List <EpisodeInfo>();
EpisodeInfo info = new EpisodeInfo
{
SeriesName = seriesSearch.SeriesName,
SeasonNumber = episodeSearch.SeasonNumber,
EpisodeName = episodeSearch.EpisodeName,
};
info.CopyIdsFrom(seriesSearch);
info.EpisodeNumbers = info.EpisodeNumbers.Union(episodeSearch.EpisodeNumbers).ToList();
info.Languages = seriesSearch.Languages;
episodes.Add(info);
}
return(episodes);
}
/// <summary>
/// Gets Series information from TvDB.
/// </summary>
/// <param name="imdbId">The IMDB id for the Series.</param>
/// <param name="series">Returns the Series information</param>
/// <returns><c>true</c> if successful</returns>
public bool GetSeries(string imdbId, out TvdbSearchResult series)
{
series = _tvdbHandler.GetSeriesByRemoteId(ExternalId.ImdbId, imdbId);
return(series != null);
}
private void cmdTestGetSeriesByExternalId_Click(object sender, EventArgs e)
{
TvdbDownloader downloader = new TvdbDownloader(File.ReadAllText("api_key.txt"));
TvdbSearchResult s = downloader.DownloadSeriesSearchByExternalId(ExternalId.ImdbId, txtExternalId.Text);
}
protected bool TryMatch(string seriesNameOrImdbId, bool isImdbId, bool cacheOnly, out TvdbSeries seriesDetail, int tvdbid = 0)
{
seriesDetail = null;
try
{
// Prefer memory cache
CheckCacheAndRefresh();
if (_memoryCache.TryGetValue(seriesNameOrImdbId, out seriesDetail))
{
if (tvdbid == 0 || seriesDetail.Id == tvdbid)
{
return(true);
}
}
// Load cache or create new list
List <SeriesMatch> matches;
lock (_syncObj)
matches = Settings.Load <List <SeriesMatch> >(MatchesSettingsFile) ?? new List <SeriesMatch>();
// Init empty
seriesDetail = null;
// Use cached values before doing online query
SeriesMatch match = matches.Find(m =>
(
string.Equals(m.ItemName, seriesNameOrImdbId, StringComparison.OrdinalIgnoreCase) ||
string.Equals(m.TvDBName, seriesNameOrImdbId, StringComparison.OrdinalIgnoreCase)
) && (tvdbid == 0 || m.Id == tvdbid));
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Try to lookup series \"{0}\" from cache: {1}", seriesNameOrImdbId, match != null && match.Id != 0);
// Try online lookup
if (!Init())
{
return(false);
}
// If this is a known series, only return the series details (including episodes).
if (match != null)
{
return(match.Id != 0 && _tv.GetSeries(match.Id, true, out seriesDetail));
}
if (cacheOnly)
{
return(false);
}
TvdbSearchResult matchedSeries = null;
bool foundResult = false;
if (tvdbid != 0)
{
foundResult = _tv.GetSeries(tvdbid, true, out seriesDetail);
}
else
if (isImdbId)
{
// If we got an IMDBID, use it to lookup by key directly
_tv.GetSeries(seriesNameOrImdbId, out matchedSeries);
}
else
{
// Otherwise we try to find unique series by name
List <TvdbSearchResult> series;
if (_tv.SearchSeriesUnique(seriesNameOrImdbId, out series))
{
matchedSeries = series[0];
}
}
if (matchedSeries != null)
{
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Found unique online match for \"{0}\": \"{1}\" [Lang: {2}]", seriesNameOrImdbId, matchedSeries.SeriesName, matchedSeries.Language);
foundResult = _tv.GetSeries(matchedSeries.Id, true, out seriesDetail);
}
if (foundResult)
{
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Loaded details for \"{0}\"", seriesDetail.SeriesName);
// Add this match to cache
SeriesMatch onlineMatch = new SeriesMatch
{
ItemName = seriesNameOrImdbId,
Id = seriesDetail.Id,
TvDBName = seriesDetail.SeriesName
};
// Save cache
_storage.TryAddMatch(onlineMatch);
return(true);
}
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: No unique match found for \"{0}\"", seriesNameOrImdbId);
// Also save "non matches" to avoid retrying
_storage.TryAddMatch(new SeriesMatch {
ItemName = seriesNameOrImdbId
});
return(false);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Exception while processing series {0}", ex, seriesNameOrImdbId);
return(false);
}
finally
{
if (seriesDetail != null)
{
_memoryCache.TryAdd(seriesNameOrImdbId, seriesDetail);
}
}
}
private void GetTvDBInfo(string searchMedia, string selectedLang, string fallbackLang)
{
const string tvDBFanartPath = "http://thetvdb.com/banners/";
InitLists();
string regexSearch = AppSettings.TvDBParseString;
regexSearch =
regexSearch.Replace("%show%", @"(?<show>[\w\s]*)")
.Replace("%season%", @"(?<season>[\d]*)")
.Replace("%episode%", @"(?<episode>[\d]*)")
.Replace("%episode_name%", @"(?<episodename>[\w\s]*)");
Regex searchObj = new Regex(regexSearch, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
Match matchResult = searchObj.Match(searchMedia);
// check first if we can use the search string
if (!matchResult.Success)
{
regexSearch = regexSearch.Replace(@"(?<episodename>[\w\s]*)", "").Trim().TrimEnd(new [] { '-' }).Trim();
searchObj = new Regex(regexSearch, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
matchResult = searchObj.Match(searchMedia);
if (!matchResult.Success)
{
return;
}
}
TvdbLanguage dbLang = _tvDbclient.Languages.Single(language => language.Abbriviation == selectedLang) ??
_tvDbclient.Languages.Single(language => language.Abbriviation == fallbackLang);
List <TvdbSearchResult> searchResults = _tvDbclient.SearchSeries(matchResult.Groups["show"].Value, dbLang);
if (searchResults == null)
{
return;
}
TvdbSearchResult resultShow = new TvdbSearchResult();
if (searchResults.Count > 1)
{
DBMultipleSelection selectWindow = new DBMultipleSelection
{
Owner = this,
TvdbSearchResults = searchResults
};
if (selectWindow.ShowDialog() == true)
{
resultShow = selectWindow.TvdbSelectionResult;
}
}
else
{
resultShow = searchResults.Count > 0 ? searchResults.First() : null;
}
if (resultShow == null || resultShow.Id == 0)
{
return;
}
TvdbSeries series = _tvDbclient.GetSeries(resultShow.Id, dbLang, true, true, true, true);
TvShowTitle.Text = series.SeriesName;
TvShowGenre.Text = string.Join(" / ", series.Genre);
TvShowRating.Text = series.Rating.ToString("g", AppSettings.CInfo);
TvShowRuntime.Text = series.Runtime.ToString("g", AppSettings.CInfo);
TvShowFirstAired.Text = series.FirstAired.ToString("yyyy-MM-dd");
TvShowPlot.Text = series.Overview;
TvShowMpaaRating.Text = series.ContentRating;
TvShowImdbId.Text = series.ImdbId;
TvShowNetwork.Text = series.Network;
foreach (TvdbEpisode episode in series.Episodes)
{
DBTvShowSeason season;
try
{
season = _seasonList.First(showSeason => showSeason.SeasonNumber == episode.SeasonNumber);
}
catch (InvalidOperationException)
{
season = new DBTvShowSeason
{
SeasonNumber = episode.SeasonNumber,
Title = episode.IsSpecial ? "Special" : "Season " + episode.SeasonNumber
};
_seasonList.Add(season);
}
season.Episodes.Add(new DBTvShowEpisode
{
Directors = episode.Directors,
Writers = episode.Writer,
SeasonNumber = episode.SeasonNumber,
Runtime = (int)series.Runtime,
Rating = episode.Rating,
Plot = episode.Overview,
IsSpecial = episode.IsSpecial,
ImdbId = episode.ImdbId,
GuestStars = episode.GuestStars,
FirstAired = episode.FirstAired,
EpisodeTitle = episode.EpisodeName,
EpisodeNumber = episode.EpisodeNumber,
DvdEpisodeNumber = episode.DvdEpisodeNumber,
CombinedEpisodeNumber = episode.CombinedEpisodeNumber,
AbsoluteEpisodeNumber = episode.AbsoluteNumber,
EpisodeImageUrl = tvDBFanartPath + episode.BannerPath,
});
}
TvShowSeason.ItemsSource = _seasonList;
int tempInt;
int.TryParse(matchResult.Groups["season"].Value, NumberStyles.Integer, AppSettings.CInfo, out tempInt);
TvShowSeason.SelectedIndex = _seasonList.ToList().FindIndex(season => season.SeasonNumber == tempInt);
int.TryParse(matchResult.Groups["episode"].Value, NumberStyles.Integer, AppSettings.CInfo, out tempInt);
TvShowEpisodeNumber.SelectedIndex =
((List <DBTvShowEpisode>)TvShowEpisodeNumber.Items.SourceCollection).FindIndex(
episode => episode.EpisodeNumber == tempInt);
int imageCounter = 1;
foreach (TvdbSeriesBanner banner in series.SeriesBanners)
{
_bannerList.Add(new MovieDBBannerImage
{
UrlOriginal = tvDBFanartPath + banner.BannerPath,
UrlPreview =
tvDBFanartPath + (!string.IsNullOrEmpty(banner.ThumbPath)
? banner.ThumbPath
: "_cache/" + banner.BannerPath),
Title = "Online image " + imageCounter
});
imageCounter++;
}
foreach (TvdbSeasonBanner banner in series.SeasonBanners)
{
_seasonBannerList.Add(new MovieDBSeasonBannerImage
{
UrlOriginal = tvDBFanartPath + banner.BannerPath,
UrlPreview =
tvDBFanartPath + (!string.IsNullOrEmpty(banner.ThumbPath)
? banner.ThumbPath
: "_cache/" + banner.BannerPath),
Title = "Online image " + imageCounter,
Season = banner.Season
});
imageCounter++;
}
_bannerList.ToList().ForEach(image => _previewBannerList.Add(image));
_seasonBannerList.ToList().ForEach(image => _previewBannerList.Add(image));
imageCounter = 1;
foreach (TvdbFanartBanner banner in series.FanartBanners)
{
_backdropsList.Add(new MovieDBImageInfo
{
Title = "Online image " + imageCounter,
UrlOriginal = tvDBFanartPath + banner.BannerPath,
UrlPreview =
tvDBFanartPath + (!string.IsNullOrEmpty(banner.ThumbPath)
? banner.ThumbPath
: "_cache/" + banner.BannerPath)
});
imageCounter++;
}
imageCounter = 1;
foreach (TvdbPosterBanner banner in series.PosterBanners)
{
_postersList.Add(new MovieDBPosterImage
{
Title = "Online image " + imageCounter,
UrlOriginal = tvDBFanartPath + banner.BannerPath,
UrlPreview =
tvDBFanartPath + (!string.IsNullOrEmpty(banner.ThumbPath)
? banner.ThumbPath
: "_cache/" + banner.BannerPath)
});
imageCounter++;
}
TvShowBannerList.ItemsSource = _previewBannerList;
TvShowBannerList.SelectedValue = tvDBFanartPath + "_cache/" + series.BannerPath;
TvShowFanartList.ItemsSource = _backdropsList;
TvShowFanartList.SelectedValue = tvDBFanartPath + "_cache/" + series.FanartPath;
TvShowPosterList.ItemsSource = _postersList;
TvShowPosterList.SelectedValue = tvDBFanartPath + "_cache/" + series.PosterPath;
foreach (TvdbActor actor in series.TvdbActors)
{
_castList.Casts.Add(new MovieDBCast
{
Name = actor.Name,
Role = actor.Role,
Thumbnail =
actor.ActorImage != null && !string.IsNullOrEmpty(actor.ActorImage.BannerPath)
? tvDBFanartPath + actor.ActorImage.BannerPath
: string.Empty
});
}
TvShowCastList.ItemsSource = _castList.Casts;
ResultTabControl.SelectedIndex = 2;
}
protected bool TryMatch(string seriesName, bool cacheOnly, out TvdbSeries seriesDetail)
{
seriesDetail = null;
try
{
// Prefer memory cache
if (_memoryCache.TryGetValue(seriesName, out seriesDetail))
{
return(true);
}
// Load cache or create new list
List <SeriesMatch> matches;
lock (_syncObj)
matches = Settings.Load <List <SeriesMatch> >(MatchesSettingsFile) ?? new List <SeriesMatch>();
// Init empty
seriesDetail = null;
// Use cached values before doing online query
SeriesMatch match = matches.Find(m => m.ItemName == seriesName || m.TvDBName == seriesName);
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Try to lookup series \"{0}\" from cache: {1}", seriesName, match != null && match.Id != 0);
// Try online lookup
if (!Init())
{
return(false);
}
// If this is a known series, only return the series details (including episodes).
if (match != null)
{
return(match.Id != 0 && _tv.GetSeries(match.Id, true, out seriesDetail));
}
if (cacheOnly)
{
return(false);
}
List <TvdbSearchResult> series;
if (_tv.SearchSeriesUnique(seriesName, out series))
{
TvdbSearchResult matchedSeries = series[0];
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Found unique online match for \"{0}\": \"{1}\" [Lang: {2}]", seriesName, matchedSeries.SeriesName, matchedSeries.Language);
if (_tv.GetSeries(matchedSeries.Id, true, out seriesDetail))
{
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Loaded details for \"{0}\"", matchedSeries.SeriesName);
// Add this match to cache
SeriesMatch onlineMatch = new SeriesMatch
{
ItemName = seriesName,
Id = seriesDetail.Id,
TvDBName = seriesDetail.SeriesName
};
// Save cache
_storage.SaveNewMatch(seriesName, onlineMatch);
return(true);
}
}
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: No unique match found for \"{0}\"", seriesName);
// Also save "non matches" to avoid retrying
_storage.SaveNewMatch(seriesName, new SeriesMatch {
ItemName = seriesName
});
return(false);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("SeriesTvDbMatcher: Exception while processing series {0}", ex, seriesName);
return(false);
}
finally
{
if (seriesDetail != null && !_memoryCache.ContainsKey(seriesName))
{
_memoryCache.Add(seriesName, seriesDetail);
}
}
}
