public List <TVDB_Series_Search_Response> SearchTheTvDB(string criteria)
{
try
{
return(TvDBApiHelper.SearchSeries(criteria));
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
return(new List <TVDB_Series_Search_Response>());
}
}
public List <TvDB_Language> GetTvDBLanguages()
{
try
{
return(TvDBApiHelper.GetLanguages());
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
}
return(new List <TvDB_Language>());
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_TvDBUpdateSeries: {0}", TvDBSeriesID);
try
{
TvDBApiHelper.UpdateSeriesInfoAndImages(TvDBSeriesID, ForceRefresh, true);
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_TvDBUpdateSeries: {0} - {1}", TvDBSeriesID,
ex);
}
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_TvDBDownloadImages: {0}", TvDBSeriesID);
try
{
TvDBApiHelper.DownloadAutomaticImages(TvDBSeriesID, ForceRefresh);
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_TvDBDownloadImages: {0} - {1}", TvDBSeriesID,
ex);
}
}
public string LinkAniDBTvDBEpisode(int aniDBID, int tvDBID)
{
try
{
TvDBApiHelper.LinkAniDBTvDBEpisode(aniDBID, tvDBID);
return(string.Empty);
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
return(ex.Message);
}
}
public override void Run(IProgress <ICommand> progress = null)
{
logger.Info("Processing CommandRequest_TvDBUpdateSeries: {0}", TvDBSeriesID);
try
{
ReportInit(progress);
TvDBApiHelper.UpdateSeriesInfoAndImages(TvDBSeriesID, ForceRefresh, true);
ReportFinish(progress);
}
catch (Exception ex)
{
ReportError(progress, $"Error processing CommandRequest_TvDBUpdateSeries: {TvDBSeriesID} - {ex}", ex);
}
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_LinkAniDBTvDB: {0}", animeID);
try
{
TvDBApiHelper.LinkAniDBTvDB(animeID, aniEpType, aniEpNumber, tvDBID, tvSeasonNumber, tvEpNumber,
excludeFromWebCache, additiveLink);
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_LinkAniDBTvDB: {0} - {1}", animeID,
ex);
}
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_LinkAniDBTvDB: {0}", animeID);
try
{
TvDBApiHelper.LinkAniDBTvDB(animeID, tvDBID, additiveLink);
SVR_AniDB_Anime.UpdateStatsByAnimeID(animeID);
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_LinkAniDBTvDB: {0} - {1}", animeID,
ex);
}
}
public override void Run(IProgress <ICommand> progress = null)
{
logger.Info("Processing CommandRequest_TvDBUpdateEpisode: {0} ({1})", InfoString, TvDBEpisodeID);
try
{
ReportInit(progress);
var ep = TvDBApiHelper.UpdateEpisode(TvDBEpisodeID, DownloadImages, ForceRefresh);
if (ep == null)
{
ReportFinish(progress);
return;
}
ReportUpdate(progress, 25);
var xref = Repo.Instance.CrossRef_AniDB_Provider.GetByProvider(CrossRefType.TvDB, ep.SeriesID.ToString()).DistinctBy(a => a.AnimeID);
if (xref == null)
{
ReportFinish(progress);
return;
}
ReportUpdate(progress, 50);
foreach (var crossRefAniDbTvDbv2 in xref)
{
var anime = Repo.Instance.AnimeSeries.GetByAnimeID(crossRefAniDbTvDbv2.AnimeID);
if (anime == null)
{
continue;
}
var episodes = Repo.Instance.AnimeEpisode.GetBySeriesID(anime.AnimeSeriesID);
foreach (SVR_AnimeEpisode episode in episodes)
{
// Save
if ((episode.TvDBEpisode?.Id ?? TvDBEpisodeID) != TvDBEpisodeID)
{
continue;
}
Repo.Instance.AnimeEpisode.Touch(episode);
}
anime.QueueUpdateStats();
}
ReportFinish(progress);
}
catch (Exception ex)
{
ReportError(progress, $"Error Processing CommandRequest_TvDBUpdateEpisode: {InfoString} ({TvDBEpisodeID})", ex);
}
}
public override void Run(IProgress <ICommand> progress = null)
{
logger.Info("Processing CommandRequest_LinkAniDBTvDB: {0}", AnimeID);
try
{
ReportInit(progress);
TvDBApiHelper.LinkAniDBTvDB(AnimeID, TvDBID, AdditiveLink);
ReportUpdate(progress, 50);
SVR_AniDB_Anime.UpdateStatsByAnimeID(AnimeID);
ReportFinish(progress);
}
catch (Exception ex)
{
ReportError(progress, $"Error processing CommandRequest_LinkAniDBTvDB: {AnimeID} - {TvDBID} - {ex}", ex);
}
}
private bool ProcessSearchResults(List <TVDB_Series_Search_Response> results, string searchCriteria)
{
TvDB_Series tvser;
switch (results.Count)
{
case 1:
// since we are using this result, lets download the info
logger.Trace("Found 1 tvdb results for search on {0} --- Linked to {1} ({2})", searchCriteria,
results[0].SeriesName,
results[0].SeriesID);
tvser = TvDBApiHelper.GetSeriesInfoOnline(results[0].SeriesID, false);
TvDBApiHelper.LinkAniDBTvDB(AnimeID, results[0].SeriesID, true);
// add links for multiple seasons (for long shows)
AddCrossRef_AniDB_TvDBV2(AnimeID, results[0].SeriesID, CrossRefSource.Automatic);
SVR_AniDB_Anime.UpdateStatsByAnimeID(AnimeID);
return(true);
case 0:
return(false);
default:
logger.Trace("Found multiple ({0}) tvdb results for search on so checking for english results {1}",
results.Count,
searchCriteria);
foreach (TVDB_Series_Search_Response sres in results)
{
// since we are using this result, lets download the info
logger.Trace("Found english result for search on {0} --- Linked to {1} ({2})", searchCriteria,
sres.SeriesName,
sres.SeriesID);
tvser = TvDBApiHelper.GetSeriesInfoOnline(results[0].SeriesID, false);
TvDBApiHelper.LinkAniDBTvDB(AnimeID, sres.SeriesID, true);
// add links for multiple seasons (for long shows)
AddCrossRef_AniDB_TvDBV2(AnimeID, results[0].SeriesID, CrossRefSource.Automatic);
SVR_AniDB_Anime.UpdateStatsByAnimeID(AnimeID);
return(true);
}
logger.Trace("No english results found, so SKIPPING: {0}", searchCriteria);
return(false);
}
}
public string RemoveLinkAniDBTvDBForAnime(int animeID)
{
try
{
SVR_AnimeSeries ser = RepoFactory.AnimeSeries.GetByAnimeID(animeID);
if (ser == null)
{
return("Could not find Series for Anime!");
}
List <CrossRef_AniDB_TvDB> xrefs = RepoFactory.CrossRef_AniDB_TvDB.GetByAnimeID(animeID);
if (xrefs == null)
{
return(string.Empty);
}
foreach (CrossRef_AniDB_TvDB xref in xrefs)
{
// check if there are default images used associated
List <AniDB_Anime_DefaultImage> images = RepoFactory.AniDB_Anime_DefaultImage.GetByAnimeID(animeID);
foreach (AniDB_Anime_DefaultImage image in images)
{
if (image.ImageParentType == (int)ImageEntityType.TvDB_Banner ||
image.ImageParentType == (int)ImageEntityType.TvDB_Cover ||
image.ImageParentType == (int)ImageEntityType.TvDB_FanArt)
{
if (image.ImageParentID == xref.TvDBID)
{
RepoFactory.AniDB_Anime_DefaultImage.Delete(image.AniDB_Anime_DefaultImageID);
}
}
}
TvDBApiHelper.RemoveLinkAniDBTvDB(xref.AniDBID, xref.TvDBID);
}
return(string.Empty);
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
return(ex.Message);
}
}
public List <int> GetSeasonNumbersForSeries(int seriesID)
{
List <int> seasonNumbers = new List <int>();
try
{
// refresh data from TvDB
TvDBApiHelper.UpdateSeriesInfoAndImages(seriesID, true, false);
seasonNumbers = RepoFactory.TvDB_Episode.GetSeasonNumbersForSeries(seriesID);
return(seasonNumbers);
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
return(seasonNumbers);
}
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_TvDBUpdateEpisode: {0} ({1})", InfoString, TvDBEpisodeID);
try
{
var ep = TvDBApiHelper.UpdateEpisode(TvDBEpisodeID, DownloadImages, ForceRefresh);
if (ep == null)
{
return;
}
var xref = RepoFactory.CrossRef_AniDB_TvDBV2.GetByTvDBID(ep.SeriesID).DistinctBy(a => a.AnimeID);
if (xref == null)
{
return;
}
foreach (var crossRefAniDbTvDbv2 in xref)
{
var anime = RepoFactory.AnimeSeries.GetByAnimeID(crossRefAniDbTvDbv2.AnimeID);
if (anime == null)
{
continue;
}
var episodes = RepoFactory.AnimeEpisode.GetBySeriesID(anime.AnimeSeriesID);
foreach (SVR_AnimeEpisode episode in episodes)
{
// Save
if ((episode.TvDBEpisode?.Id ?? TvDBEpisodeID) != TvDBEpisodeID)
{
continue;
}
episode.TvDBEpisode = null;
RepoFactory.AnimeEpisode.Save(episode);
}
anime.QueueUpdateStats();
}
}
catch (Exception ex)
{
logger.Error(ex, "Error Processing CommandRequest_TvDBUpdateEpisode: {0} ({1})", InfoString, TvDBEpisodeID);
}
}
public string RemoveLinkAniDBTvDBForAnime(int animeID)
{
try
{
SVR_AnimeSeries ser = Repo.Instance.AnimeSeries.GetByAnimeID(animeID);
if (ser == null)
{
return("Could not find Series for Anime!");
}
// check if there are default images used associated
Repo.Instance.AniDB_Anime_DefaultImage.FindAndDelete(() => Repo.Instance.AniDB_Anime_DefaultImage.GetByAnimeID(animeID).Where(a => a.ImageParentType == (int)ImageEntityType.TvDB_Banner || a.ImageParentType == (int)ImageEntityType.TvDB_Cover || a.ImageParentType == (int)ImageEntityType.TvDB_FanArt).ToList());
TvDBApiHelper.RemoveAllAniDBTvDBLinks(animeID, true);
return(string.Empty);
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
return(ex.Message);
}
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_TvDBSearchAnime: {0}", AnimeID);
try
{
// first check if the user wants to use the web cache
if (ServerSettings.Instance.WebCache.TvDB_Get)
{
try
{
List <Azure_CrossRef_AniDB_TvDB> cacheResults =
AzureWebAPI.Get_CrossRefAniDBTvDB(AnimeID);
if (cacheResults != null && cacheResults.Count > 0)
{
// check again to see if there are any links, user may have manually added links while
// this command was in the queue
List <CrossRef_AniDB_TvDB> xrefTemp =
RepoFactory.CrossRef_AniDB_TvDB.GetByAnimeID(AnimeID);
if (xrefTemp != null && xrefTemp.Count > 0)
{
return;
}
// Add overrides for specials
var specialXRefs = cacheResults.Where(a => a.TvDBSeasonNumber == 0)
.OrderBy(a => a.AniDBStartEpisodeType).ThenBy(a => a.AniDBStartEpisodeNumber)
.ToList();
if (specialXRefs.Count != 0)
{
var overrides = TvDBLinkingHelper.GetSpecialsOverridesFromLegacy(specialXRefs);
foreach (var episodeOverride in overrides)
{
var exists =
RepoFactory.CrossRef_AniDB_TvDB_Episode_Override.GetByAniDBAndTvDBEpisodeIDs(
episodeOverride.AniDBEpisodeID, episodeOverride.TvDBEpisodeID);
if (exists != null)
{
continue;
}
RepoFactory.CrossRef_AniDB_TvDB_Episode_Override.Save(episodeOverride);
}
}
foreach (Azure_CrossRef_AniDB_TvDB xref in cacheResults)
{
TvDB_Series tvser = TvDBApiHelper.GetSeriesInfoOnline(xref.TvDBID, false);
if (tvser != null)
{
logger.Trace("Found tvdb match on web cache for {0}", AnimeID);
TvDBApiHelper.LinkAniDBTvDB(AnimeID, xref.TvDBID, true);
}
}
return;
}
}
catch (Exception)
{
}
}
if (!ServerSettings.Instance.TvDB.AutoLink)
{
return;
}
// try to pull a link from a prequel/sequel
var relations = RepoFactory.AniDB_Anime_Relation.GetFullLinearRelationTree(AnimeID);
int?tvDBID = relations.SelectMany(a => RepoFactory.CrossRef_AniDB_TvDB.GetByAnimeID(a))
.FirstOrDefault(a => a != null)?.TvDBID;
if (tvDBID != null)
{
TvDBApiHelper.LinkAniDBTvDB(AnimeID, tvDBID.Value, true);
return;
}
// search TvDB
SVR_AniDB_Anime anime = RepoFactory.AniDB_Anime.GetByAnimeID(AnimeID);
if (anime == null)
{
return;
}
var searchCriteria = anime.MainTitle;
// if not wanting to use web cache, or no match found on the web cache go to TvDB directly
List <TVDB_Series_Search_Response> results = TvDBApiHelper.SearchSeries(searchCriteria);
logger.Trace("Found {0} tvdb results for {1} on TheTvDB", results.Count, searchCriteria);
if (ProcessSearchResults(results, searchCriteria))
{
return;
}
if (results.Count != 0)
{
return;
}
bool foundResult = false;
foreach (AniDB_Anime_Title title in anime.GetTitles())
{
if (!title.TitleType.Equals(Shoko.Models.Constants.AnimeTitleType.Official, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (!title.Language.Equals(Shoko.Models.Constants.AniDBLanguageType.English,
StringComparison.InvariantCultureIgnoreCase) &&
!title.Language.Equals(Shoko.Models.Constants.AniDBLanguageType.Romaji,
StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (searchCriteria.Equals(title.Title, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
searchCriteria = title.Title;
results = TvDBApiHelper.SearchSeries(searchCriteria);
if (results.Count > 0)
{
foundResult = true;
}
logger.Trace("Found {0} tvdb results for search on {1}", results.Count, title.Title);
if (ProcessSearchResults(results, title.Title))
{
return;
}
}
if (!foundResult)
{
logger.Warn("Unable to find a matching TvDB series for {0}", anime.MainTitle);
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_TvDBSearchAnime: {0} - {1}", AnimeID, ex);
}
}
public override void Run(IProgress <ICommand> progress = null)
{
logger.Info("Processing CommandRequest_TvDBSearchAnime: {0}", AnimeID);
try
{
ReportInit(progress);
// first check if the user wants to use the web cache
if (ServerSettings.Instance.WebCache.TvDB_Get)
{
try
{
List <WebCache_CrossRef_AniDB_Provider> resultsCache = WebCacheAPI.Instance.GetCrossRef_AniDB_Provider(AnimeID, CrossRefType.TvDB);
ReportUpdate(progress, 30);
if (resultsCache != null && resultsCache.Count > 0)
{
List <WebCache_CrossRef_AniDB_Provider> best = resultsCache.BestProvider();
if (best.Count > 0)
{
TvDBApiHelper.RemoveAllAniDBTvDBLinks(AnimeID, false);
ReportUpdate(progress, 70);
foreach (WebCache_CrossRef_AniDB_Provider xref in best)
{
TvDBApiHelper.LinkAniDBTvDBFromWebCache(xref);
}
SVR_AniDB_Anime.UpdateStatsByAnimeID(AnimeID);
logger.Trace("Changed trakt association: {0}", AnimeID);
ReportFinish(progress);
return;
}
}
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
}
}
if (!ServerSettings.Instance.TvDB.AutoLink)
{
ReportFinish(progress);
return;
}
// try to pull a link from a prequel/sequel
var relations = Repo.Instance.AniDB_Anime_Relation.GetFullLinearRelationTree(AnimeID);
string tvDBID = relations.SelectMany(a => Repo.Instance.CrossRef_AniDB_Provider.GetByAnimeIDAndType(a, CrossRefType.TvDB))
.FirstOrDefault(a => a != null)?.CrossRefID;
ReportUpdate(progress, 25);
if (tvDBID != null)
{
TvDBApiHelper.LinkAniDBTvDB(AnimeID, int.Parse(tvDBID), true);
ReportFinish(progress);
return;
}
ReportUpdate(progress, 50);
// search TvDB
SVR_AniDB_Anime anime = Repo.Instance.AniDB_Anime.GetByAnimeID(AnimeID);
if (anime == null)
{
ReportFinish(progress);
return;
}
var searchCriteria = anime.MainTitle;
// if not wanting to use web cache, or no match found on the web cache go to TvDB directly
List <TVDB_Series_Search_Response> results = TvDBApiHelper.SearchSeries(searchCriteria);
logger.Trace("Found {0} tvdb results for {1} on TheTvDB", results.Count, searchCriteria);
if (ProcessSearchResults(results, searchCriteria))
{
ReportFinish(progress);
return;
}
if (results.Count != 0)
{
ReportFinish(progress);
return;
}
bool foundResult = false;
ReportUpdate(progress, 75);
foreach (AniDB_Anime_Title title in anime.GetTitles())
{
if (!title.TitleType.Equals(Shoko.Models.Constants.AnimeTitleType.Official, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (!title.Language.Equals(Shoko.Models.Constants.AniDBLanguageType.English,
StringComparison.InvariantCultureIgnoreCase) &&
!title.Language.Equals(Shoko.Models.Constants.AniDBLanguageType.Romaji,
StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (searchCriteria.Equals(title.Title, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
searchCriteria = title.Title;
results = TvDBApiHelper.SearchSeries(searchCriteria);
if (results.Count > 0)
{
foundResult = true;
}
logger.Trace("Found {0} tvdb results for search on {1}", results.Count, title.Title);
if (ProcessSearchResults(results, title.Title))
{
ReportFinish(progress);
return;
}
}
if (!foundResult)
{
logger.Warn("Unable to find a matching TvDB series for {0}", anime.MainTitle);
}
ReportFinish(progress);
}
catch (Exception ex)
{
ReportError(progress, $"Error processing CommandRequest_TvDBSearchAnime: {AnimeID} - {ex}", ex);
}
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_TvDBSearchAnime: {0}", AnimeID);
try
{
using (var session = DatabaseFactory.SessionFactory.OpenSession())
{
// first check if the user wants to use the web cache
if (ServerSettings.WebCache_TvDB_Get)
{
try
{
List <Azure_CrossRef_AniDB_TvDB> cacheResults =
AzureWebAPI.Get_CrossRefAniDBTvDB(AnimeID);
if (cacheResults != null && cacheResults.Count > 0)
{
// check again to see if there are any links, user may have manually added links while
// this command was in the queue
List <CrossRef_AniDB_TvDBV2> xrefTemp =
RepoFactory.CrossRef_AniDB_TvDBV2.GetByAnimeID(AnimeID);
if (xrefTemp != null && xrefTemp.Count > 0)
{
return;
}
foreach (Azure_CrossRef_AniDB_TvDB xref in cacheResults)
{
TvDB_Series tvser = TvDBApiHelper.GetSeriesInfoOnline(xref.TvDBID, false);
if (tvser != null)
{
logger.Trace("Found tvdb match on web cache for {0}", AnimeID);
TvDBApiHelper.LinkAniDBTvDB(AnimeID,
(EpisodeType)xref.AniDBStartEpisodeType,
xref.AniDBStartEpisodeNumber,
xref.TvDBID, xref.TvDBSeasonNumber,
xref.TvDBStartEpisodeNumber, true, true);
}
}
return;
}
}
catch (Exception)
{
}
}
if (!ServerSettings.TvDB_AutoLink)
{
return;
}
string searchCriteria = string.Empty;
SVR_AniDB_Anime anime = RepoFactory.AniDB_Anime.GetByAnimeID(AnimeID);
if (anime == null)
{
return;
}
searchCriteria = anime.MainTitle;
// if not wanting to use web cache, or no match found on the web cache go to TvDB directly
List <TVDB_Series_Search_Response> results = TvDBApiHelper.SearchSeries(searchCriteria);
logger.Trace("Found {0} tvdb results for {1} on TheTvDB", results.Count, searchCriteria);
if (ProcessSearchResults(results, searchCriteria))
{
return;
}
if (results.Count == 0)
{
bool foundResult = false;
foreach (AniDB_Anime_Title title in anime.GetTitles())
{
if (!title.TitleType.Equals(Shoko.Models.Constants.AnimeTitleType.Official, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (!title.Language.Equals(Shoko.Models.Constants.AniDBLanguageType.English,
StringComparison.InvariantCultureIgnoreCase) &&
!title.Language.Equals(Shoko.Models.Constants.AniDBLanguageType.Romaji,
StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (searchCriteria.Equals(title.Title, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
searchCriteria = title.Title;
results = TvDBApiHelper.SearchSeries(searchCriteria);
if (results.Count > 0)
{
foundResult = true;
}
logger.Trace("Found {0} tvdb results for search on {1}", results.Count, title.Title);
if (ProcessSearchResults(results, title.Title))
{
return;
}
}
if (!foundResult)
{
logger.Warn("Unable to find a matching TvDB series for {0}", anime.MainTitle);
}
}
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_TvDBSearchAnime: {0} - {1}", AnimeID, ex);
}
}
private bool ProcessSearchResults(List <TVDB_Series_Search_Response> results, string searchCriteria)
{
if (results.Count == 1)
{
// since we are using this result, lets download the info
logger.Trace("Found 1 tvdb results for search on {0} --- Linked to {1} ({2})", searchCriteria,
results[0].SeriesName,
results[0].SeriesID);
TvDB_Series tvser = TvDBApiHelper.GetSeriesInfoOnline(results[0].SeriesID, false);
TvDBApiHelper.LinkAniDBTvDB(AnimeID, EpisodeType.Episode, 1, results[0].SeriesID, 1, 1, true);
// add links for multiple seasons (for long shows)
List <int> seasons = RepoFactory.TvDB_Episode.GetSeasonNumbersForSeries(results[0].SeriesID);
foreach (int season in seasons)
{
if (season < 2)
{
continue; // we just linked season 1, so start after (and skip specials)
}
TvDB_Episode ep = RepoFactory.TvDB_Episode.GetBySeriesIDSeasonNumberAndEpisode(results[0].SeriesID, season, 1);
if (ep?.AbsoluteNumber != null)
{
AddCrossRef_AniDB_TvDBV2(AnimeID, ep.AbsoluteNumber.Value, results[0].SeriesID,
season, tvser?.SeriesName ?? string.Empty);
}
}
SVR_AniDB_Anime.UpdateStatsByAnimeID(AnimeID);
return(true);
}
if (results.Count > 1)
{
logger.Trace("Found multiple ({0}) tvdb results for search on so checking for english results {1}",
results.Count,
searchCriteria);
foreach (TVDB_Series_Search_Response sres in results)
{
// since we are using this result, lets download the info
logger.Trace("Found english result for search on {0} --- Linked to {1} ({2})", searchCriteria,
sres.SeriesName,
sres.SeriesID);
TvDB_Series tvser = TvDBApiHelper.GetSeriesInfoOnline(results[0].SeriesID, false);
TvDBApiHelper.LinkAniDBTvDB(AnimeID, EpisodeType.Episode, 1, sres.SeriesID, 1, 1, true);
// add links for multiple seasons (for long shows)
List <int> seasons = RepoFactory.TvDB_Episode.GetSeasonNumbersForSeries(results[0].SeriesID);
foreach (int season in seasons)
{
if (season < 2)
{
continue; // we just linked season 1, so start after (and skip specials)
}
TvDB_Episode ep = RepoFactory.TvDB_Episode
.GetBySeriesIDSeasonNumberAndEpisode(results[0].SeriesID, season, 1);
if (ep?.AbsoluteNumber != null)
{
AddCrossRef_AniDB_TvDBV2(AnimeID, ep.AbsoluteNumber.Value, results[0].SeriesID,
season, tvser?.SeriesName ?? string.Empty);
}
}
return(true);
}
logger.Trace("No english results found, so SKIPPING: {0}", searchCriteria);
}
return(false);
}
