private bool ProcessSearchResults(List <TVDBSeriesSearchResult> 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 = TvDBHelper.GetSeriesInfoOnline(results[0].SeriesID);
TvDBHelper.LinkAniDBTvDB(AnimeID, AniDBAPI.enEpisodeType.Episode, 1, results[0].SeriesID, 1, 1, true);
return(true);
}
else if (results.Count > 1)
{
logger.Trace("Found multiple ({0}) tvdb results for search on so checking for english results {1}",
results.Count,
searchCriteria);
foreach (TVDBSeriesSearchResult sres in results)
{
if (sres.Language.Equals("en", StringComparison.InvariantCultureIgnoreCase))
{
// 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 = TvDBHelper.GetSeriesInfoOnline(results[0].SeriesID);
TvDBHelper.LinkAniDBTvDB(AnimeID, AniDBAPI.enEpisodeType.Episode, 1, sres.SeriesID, 1, 1, true);
return(true);
}
}
logger.Trace("No english results found, so SKIPPING: {0}", searchCriteria);
}
return(false);
}
public static void LinkAniDBTvDB(int animeID, int tvDBID, bool additiveLink = false)
{
if (!additiveLink)
{
// remove all current links
logger.Info($"Removing All TvDB Links for: {animeID}");
RemoveAllAniDBTvDBLinks(animeID, false);
}
// check if we have this information locally
// if not download it now
TvDB_Series tvSeries = RepoFactory.TvDB_Series.GetByTvDBID(tvDBID);
if (tvSeries != null)
{
// download and update series info, episode info and episode images
// will also download fanart, posters and wide banners
CommandRequest_TvDBUpdateSeries cmdSeriesEps =
new CommandRequest_TvDBUpdateSeries(tvDBID,
false);
cmdSeriesEps.Save();
}
else
{
var unused = GetSeriesInfoOnlineAsync(tvDBID, true).Result;
}
CrossRef_AniDB_TvDB xref = RepoFactory.CrossRef_AniDB_TvDB.GetByAniDBAndTvDBID(animeID, tvDBID) ??
new CrossRef_AniDB_TvDB();
xref.AniDBID = animeID;
xref.TvDBID = tvDBID;
xref.CrossRefSource = CrossRefSource.User;
RepoFactory.CrossRef_AniDB_TvDB.Save(xref);
logger.Info(
$"Adding TvDB Link: AniDB(ID:{animeID}) -> TvDB(ID:{tvDBID})");
if (ServerSettings.Instance.TraktTv.Enabled && !string.IsNullOrEmpty(ServerSettings.Instance.TraktTv.AuthToken))
{
// check for Trakt associations
List <CrossRef_AniDB_TraktV2> trakt = RepoFactory.CrossRef_AniDB_TraktV2.GetByAnimeID(animeID);
if (trakt.Count != 0)
{
foreach (CrossRef_AniDB_TraktV2 a in trakt)
{
RepoFactory.CrossRef_AniDB_TraktV2.Delete(a);
}
}
var cmd2 = new CommandRequest_TraktSearchAnime(animeID, false);
cmd2.Save();
}
}
public static async Task UpdateAllInfoAndImagesAsync(int seriesID, bool forceRefresh, bool downloadImages)
{
try
{
// update the series info
TvDB_Series tvSeries = GetSeriesInfoOnline(seriesID);
if (tvSeries == null)
{
return;
}
if (downloadImages)
{
DownloadAutomaticImages(seriesID, forceRefresh);
}
List <BasicEpisode> episodeItems = GetEpisodesOnline(seriesID);
logger.Trace($"Found {episodeItems.Count} Episode nodes");
List <int> existingEpIds = new List <int>();
foreach (BasicEpisode item in episodeItems)
{
await QueueEpisodeImageDownloadAsync(item, existingEpIds, downloadImages, forceRefresh);
}
// get all the existing tvdb episodes, to see if any have been deleted
List <TvDB_Episode> allEps = RepoFactory.TvDB_Episode.GetBySeriesID(seriesID);
foreach (TvDB_Episode oldEp in allEps)
{
if (!existingEpIds.Contains(oldEp.Id))
{
RepoFactory.TvDB_Episode.Delete(oldEp.TvDB_EpisodeID);
}
}
var xref = RepoFactory.CrossRef_AniDB_TvDBV2.GetByTvDBID(seriesID).FirstOrDefault();
if (xref == null)
{
return;
}
var anime = RepoFactory.AnimeSeries.GetByAnimeID(xref.AnimeID);
if (anime == null)
{
return;
}
var episodes = RepoFactory.AnimeEpisode.GetBySeriesID(anime.AnimeSeriesID);
foreach (SVR_AnimeEpisode episode in episodes)
{
RepoFactory.AnimeEpisode.Save(episode);
}
SVR_AniDB_Anime.UpdateStatsByAnimeID(xref.AnimeID);
}
catch (Exception ex)
{
logger.Error(ex, $"Error in TVDBHelper.GetEpisodes: {ex}");
}
}
public TvDB_Series GetByTvDBID(ISession session, int id)
{
TvDB_Series cr = session
.CreateCriteria(typeof(TvDB_Series))
.Add(Restrictions.Eq("SeriesID", id))
.UniqueResult <TvDB_Series>();
return(cr);
}
public static void UpdateSeriesInfoAndImages(int seriesID, bool forceRefresh, bool downloadImages)
{
try
{
// update the series info
TvDB_Series tvSeries = GetSeriesInfoOnline(seriesID, forceRefresh);
if (tvSeries == null)
{
return;
}
if (downloadImages)
{
DownloadAutomaticImages(seriesID, forceRefresh);
}
List <BasicEpisode> episodeItems = GetEpisodesOnline(seriesID);
logger.Trace($"Found {episodeItems.Count} Episode nodes");
List <int> existingEpIds = new List <int>();
foreach (BasicEpisode item in episodeItems)
{
if (!existingEpIds.Contains(item.Id))
{
existingEpIds.Add(item.Id);
}
string infoString = $"{tvSeries.SeriesName} - Episode {item.AbsoluteNumber?.ToString() ?? "X"}";
CommandQueue.Queue.Instance.Add(new CmdTvDBUpdateEpisode(item.Id, infoString, downloadImages, forceRefresh));
}
// get all the existing tvdb episodes, to see if any have been deleted
Repo.Instance.TvDB_Episode.FindAndDelete(() =>
{
List <TvDB_Episode> todelete = new List <TvDB_Episode>();
foreach (TvDB_Episode oldEp in Repo.Instance.TvDB_Episode.GetBySeriesID(seriesID))
{
if (!existingEpIds.Contains(oldEp.Id))
{
todelete.Add(oldEp);
}
}
return(todelete);
});
// Not updating stats as it will happen with the episodes
}
catch (Exception ex)
{
logger.Error(ex, $"Error in TVDBHelper.GetEpisodes: {ex}");
}
}
public static async Task <TvDB_Series> GetSeriesInfoOnlineAsync(int seriesID, bool forceRefresh)
{
try
{
TvDB_Series tvSeries = RepoFactory.TvDB_Series.GetByTvDBID(seriesID);
if (tvSeries != null && !forceRefresh)
{
return(tvSeries);
}
await CheckAuthorizationAsync();
TvDBRateLimiter.Instance.EnsureRate();
var response = await client.Series.GetAsync(seriesID);
Series series = response.Data;
tvSeries = tvSeries ?? new TvDB_Series();
tvSeries.PopulateFromSeriesInfo(series);
RepoFactory.TvDB_Series.Save(tvSeries);
return(tvSeries);
}
catch (TvDbServerException exception)
{
if (exception.StatusCode == (int)HttpStatusCode.Unauthorized)
{
client.Authentication.Token = null;
await CheckAuthorizationAsync();
if (!string.IsNullOrEmpty(client.Authentication.Token))
{
return(await GetSeriesInfoOnlineAsync(seriesID, forceRefresh));
}
Analytics.PostEvent("TvDB", "Login Failed", "Tried to Get Series Without Login");
// suppress 404 and move on
}
else if (exception.StatusCode == (int)HttpStatusCode.NotFound)
{
Analytics.PostEvent("TvDB", "404: GetSeriesInfo", $"{seriesID}");
return(null);
}
logger.Error(exception,
$"TvDB returned an error code: {exception.StatusCode}\n {exception.Message}");
Analytics.PostException(exception);
}
catch (Exception ex)
{
logger.Error(ex, $"Error in TvDBApiHelper.GetSeriesInfoOnline: {ex}");
Analytics.PostException(ex);
}
return(null);
}
public void Save(TvDB_Series obj)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
session.SaveOrUpdate(obj);
transaction.Commit();
}
}
}
public static bool ConfirmTvDBOnline()
{
TvDB_Series tvser = GetSeriesInfoOnline(73255);
if (tvser == null)
{
return(false);
}
else
{
return(true);
}
}
public static void UpdateSeriesInfoAndImages(int seriesID, bool forceRefresh, bool downloadImages)
{
try
{
// update the series info
TvDB_Series tvSeries = GetSeriesInfoOnline(seriesID, forceRefresh);
if (tvSeries == null)
{
return;
}
if (downloadImages)
{
DownloadAutomaticImages(seriesID, forceRefresh);
}
List <EpisodeRecord> episodeItems = GetEpisodesOnline(seriesID);
logger.Trace($"Found {episodeItems.Count} Episode nodes");
List <int> existingEpIds = new List <int>();
foreach (EpisodeRecord item in episodeItems)
{
if (!existingEpIds.Contains(item.Id))
{
existingEpIds.Add(item.Id);
}
string infoString = $"{tvSeries.SeriesName} - Episode {item.AbsoluteNumber?.ToString() ?? "X"}";
CommandRequest_TvDBUpdateEpisode epcmd =
new CommandRequest_TvDBUpdateEpisode(item.Id, infoString, downloadImages, forceRefresh);
epcmd.Save();
}
// get all the existing tvdb episodes, to see if any have been deleted
List <TvDB_Episode> allEps = RepoFactory.TvDB_Episode.GetBySeriesID(seriesID);
foreach (TvDB_Episode oldEp in allEps)
{
if (!existingEpIds.Contains(oldEp.Id))
{
RepoFactory.TvDB_Episode.Delete(oldEp.TvDB_EpisodeID);
}
}
// Not updating stats as it will happen with the episodes
}
catch (Exception ex)
{
logger.Error(ex, $"Error in TVDBHelper.GetEpisodes: {ex}");
Analytics.PostException(ex);
}
}
public static async Task <TvDB_Series> GetSeriesInfoOnlineAsync(int seriesID, bool forceRefresh)
{
try
{
TvDB_Series tvSeries = Repo.Instance.TvDB_Series.GetByTvDBID(seriesID);
if (tvSeries != null && !forceRefresh)
{
return(tvSeries);
}
await CheckAuthorizationAsync();
TvDBRateLimiter.Instance.EnsureRate();
var response = await client.Series.GetAsync(seriesID);
Series series = response.Data;
using (var tupd = Repo.Instance.TvDB_Series.BeginAddOrUpdate(() => Repo.Instance.TvDB_Series.GetByTvDBID(seriesID)))
{
tupd.Entity.PopulateFromSeriesInfo(series);
tvSeries = tupd.Commit();
}
return(tvSeries);
}
catch (TvDbServerException exception)
{
if (exception.StatusCode == (int)HttpStatusCode.Unauthorized)
{
client.Authentication.Token = null;
await CheckAuthorizationAsync();
if (!string.IsNullOrEmpty(client.Authentication.Token))
{
return(await GetSeriesInfoOnlineAsync(seriesID, forceRefresh));
}
// suppress 404 and move on
}
else if (exception.StatusCode == (int)HttpStatusCode.NotFound)
{
return(null);
}
logger.Error(exception,
$"TvDB returned an error code: {exception.StatusCode}\n {exception.Message}");
}
catch (Exception ex)
{
logger.Error(ex, $"Error in TvDBApiHelper.GetSeriesInfoOnline: {ex}");
}
return(null);
}
public static async Task <TvDB_Series> GetSeriesInfoOnlineAsync(int seriesID)
{
try
{
await _checkAuthorizationAsync();
TvDBRateLimiter.Instance.EnsureRate();
var response = await client.Series.GetAsync(seriesID);
Series series = response.Data;
TvDB_Series tvSeries = RepoFactory.TvDB_Series.GetByTvDBID(seriesID);
if (tvSeries == null)
{
tvSeries = new TvDB_Series();
}
tvSeries.PopulateFromSeriesInfo(series);
RepoFactory.TvDB_Series.Save(tvSeries);
return(tvSeries);
}
catch (TvDbSharper.Errors.TvDbServerException exception)
{
if (exception.StatusCode == HttpStatusCode.Unauthorized)
{
client.Authentication.Token = null;
await _checkAuthorizationAsync();
if (client.Authentication.Token != null)
{
return(await GetSeriesInfoOnlineAsync(seriesID));
}
// suppress 404 and move on
}
else if (exception.StatusCode == HttpStatusCode.NotFound)
{
return(null);
}
logger.Error(exception, "TvDB returned an error code: " + exception.StatusCode + "\n " + exception.Message);
}
catch (Exception ex)
{
logger.Error(ex, "Error in TvDBApiHelper.GetSeriesInfoOnline: " + ex.ToString());
}
return(null);
}
public static void PopulateFromSearch(this TvDB_Series series, XmlDocument doc)
{
series.SeriesID = 0;
series.Overview = string.Empty;
series.SeriesName = string.Empty;
series.Status = string.Empty;
series.Banner = string.Empty;
series.Fanart = string.Empty;
series.Lastupdated = string.Empty;
series.Poster = string.Empty;
series.SeriesID = int.Parse(TryGetSeriesProperty(doc, "seriesid"));
series.SeriesName = TryGetSeriesProperty(doc, "SeriesName");
series.Overview = TryGetSeriesProperty(doc, "Overview");
series.Banner = TryGetSeriesProperty(doc, "banner");
}
public void Delete(int id)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
TvDB_Series cr = GetByID(id);
if (cr != null)
{
session.Delete(cr);
transaction.Commit();
}
}
}
}
/*
* public static bool ConfirmTvDBOnline()
* {
* TvDB_Series tvser = GetSeriesInfoOnline(73255);
* if (tvser == null)
* return false;
* else
* return true;
* }
*/
public static TvDB_Series GetSeriesInfoOnline(int seriesID)
{
try
{
//Init();
string url = string.Format(Constants.TvDBURLs.urlSeriesBaseXML, URLMirror, Constants.TvDBURLs.apiKey,
seriesID,
ServerSettings.TvDB_Language);
logger.Trace("GetSeriesInfo: {0}", url);
// Search for a series
string xmlSeries = Utils.DownloadWebPage(url);
logger.Trace("GetSeriesInfo RESULT: {0}", xmlSeries);
if (xmlSeries.Trim().Length == 0)
{
return(null);
}
XmlDocument docSeries = new XmlDocument();
docSeries.LoadXml(xmlSeries);
TvDB_Series tvSeries = null;
if (docSeries != null)
{
TvDB_SeriesRepository repSeries = new TvDB_SeriesRepository();
tvSeries = repSeries.GetByTvDBID(seriesID);
if (tvSeries == null)
{
tvSeries = new TvDB_Series();
}
tvSeries.PopulateFromSeriesInfo(docSeries);
repSeries.Save(tvSeries);
}
return(tvSeries);
}
catch (Exception ex)
{
logger.ErrorException("Error in TVDBHelper.GetSeriesInfoOnline: " + ex.ToString(), ex);
}
return(null);
}
public static async Task <TvDB_Series> GetSeriesInfoOnlineAsync(int seriesID)
{
try
{
await CheckAuthorizationAsync();
TvDBRateLimiter.Instance.EnsureRate();
var response = await client.Series.GetAsync(seriesID);
Series series = response.Data;
TvDB_Series tvSeries = RepoFactory.TvDB_Series.GetByTvDBID(seriesID) ?? new TvDB_Series();
tvSeries.PopulateFromSeriesInfo(series);
RepoFactory.TvDB_Series.Save(tvSeries);
return(tvSeries);
}
catch (TvDbServerException exception)
{
if (exception.StatusCode == (int)HttpStatusCode.Unauthorized)
{
client.Authentication.Token = null;
await CheckAuthorizationAsync();
if (!string.IsNullOrEmpty(client.Authentication.Token))
{
return(await GetSeriesInfoOnlineAsync(seriesID));
}
// suppress 404 and move on
}
else if (exception.StatusCode == (int)HttpStatusCode.NotFound)
{
return(null);
}
logger.Error(exception,
$"TvDB returned an error code: {exception.StatusCode}\n {exception.Message}");
}
catch (Exception ex)
{
logger.Error(ex, $"Error in TvDBApiHelper.GetSeriesInfoOnline: {ex}");
}
return(null);
}
public static void PopulateFromSeriesInfo(this TvDB_Series series, TvDbSharper.Dto.Series apiSeries)
{
series.SeriesID = 0;
series.Overview = string.Empty;
series.SeriesName = string.Empty;
series.Status = string.Empty;
series.Banner = string.Empty;
series.Fanart = string.Empty;
series.Lastupdated = string.Empty;
series.Poster = string.Empty;
series.SeriesID = apiSeries.Id;
series.SeriesName = apiSeries.SeriesName;
series.Overview = apiSeries.Overview;
series.Banner = apiSeries.Banner;
series.Status = apiSeries.Status;
series.Lastupdated = apiSeries.LastUpdated.ToString();
}
public static void PopulateFromSeriesInfo(this TvDB_Series series, XmlDocument doc)
{
series.SeriesID = 0;
series.Overview = String.Empty;
series.SeriesName = String.Empty;
series.Status = String.Empty;
series.Banner = String.Empty;
series.Fanart = String.Empty;
series.Lastupdated = String.Empty;
series.Poster = String.Empty;
series.SeriesID = Int32.Parse(TryGetSeriesProperty(doc, "id"));
series.SeriesName = TryGetSeriesProperty(doc, "SeriesName");
series.Overview = TryGetSeriesProperty(doc, "Overview");
series.Banner = TryGetSeriesProperty(doc, "banner");
series.Status = TryGetSeriesProperty(doc, "Status");
series.Fanart = TryGetSeriesProperty(doc, "fanart");
series.Lastupdated = TryGetSeriesProperty(doc, "lastupdated");
series.Poster = TryGetSeriesProperty(doc, "poster");
}
public static void LinkAniDBTvDB(int animeID, int tvDBID, bool additiveLink = false)
{
if (!additiveLink)
{
// remove all current links
logger.Info($"Removing All TvDB Links for: {animeID}");
RemoveAllAniDBTvDBLinks(animeID, false);
}
// check if we have this information locally
// if not download it now
TvDB_Series tvSeries = Repo.Instance.TvDB_Series.GetByTvDBID(tvDBID);
if (tvSeries != null)
{
// download and update series info, episode info and episode images
// will also download fanart, posters and wide banners
CommandQueue.Queue.Instance.Add(new CmdTvDBUpdateSeries(tvDBID, false));
}
else
{
var unused = GetSeriesInfoOnlineAsync(tvDBID, true).Result;
}
using (var upd = Repo.Instance.CrossRef_AniDB_Provider.BeginAddOrUpdate(() => Repo.Instance.CrossRef_AniDB_Provider.GetByAnimeIdAndProvider(CrossRefType.TvDB, animeID, tvDBID.ToString())))
{
upd.Entity.CrossRefSource = CrossRefSource.User;
upd.Entity.AnimeID = animeID;
upd.Entity.CrossRefID = tvDBID.ToString();
upd.Entity.CrossRefType = CrossRefType.TvDB;
upd.Commit();
}
logger.Info(
$"Adding TvDB Link: AniDB(ID:{animeID}) -> TvDB(ID:{tvDBID})");
if (ServerSettings.Instance.TraktTv.Enabled && !string.IsNullOrEmpty(ServerSettings.Instance.TraktTv.AuthToken))
{
CommandQueue.Queue.Instance.Add(new CmdTraktSearchAnime(animeID, false));
}
}
public TvDB(HttpContext ctx, TvDB_Series tbdbSeries, SVR_AnimeSeries series, List <SVR_AnimeEpisode> episodeList = null)
{
if (episodeList == null)
{
episodeList = series.GetAnimeEpisodes();
}
ID = tbdbSeries.SeriesID;
Description = tbdbSeries.Overview;
Title = tbdbSeries.SeriesName;
if (tbdbSeries.Rating != null)
{
Rating = new Rating {
Source = "TvDB", Value = tbdbSeries.Rating.Value, MaxValue = 10
}
}
;
Images images = new Images();
AddTvDBImages(ctx, images, series.AniDB_ID);
Posters = images.Posters;
Fanarts = images.Fanarts;
Banners = images.Banners;
// Aggregate stuff
var firstEp = episodeList.FirstOrDefault(a =>
a.AniDB_Episode != null && (a.AniDB_Episode.EpisodeType == (int)AniDBEpisodeType.Episode &&
a.AniDB_Episode.EpisodeNumber == 1))
?.TvDBEpisode;
var lastEp = episodeList
.Where(a => a.AniDB_Episode != null && (a.AniDB_Episode.EpisodeType == (int)AniDBEpisodeType.Episode))
.OrderBy(a => a.AniDB_Episode.EpisodeType)
.ThenBy(a => a.AniDB_Episode.EpisodeNumber).LastOrDefault()
?.TvDBEpisode;
Season = firstEp?.SeasonNumber;
AirDate = firstEp?.AirDate;
EndDate = lastEp?.AirDate;
}
public static void LinkAniDBTvDBFromWebCache(WebCache_CrossRef_AniDB_Provider cache)
{
// check if we have this information locally
// if not download it now
int tvDBID = int.Parse(cache.CrossRefID);
TvDB_Series tvSeries = Repo.Instance.TvDB_Series.GetByTvDBID(tvDBID);
if (tvSeries == null)
{
tvSeries = Task.Run(async() => await GetSeriesInfoOnlineAsync(tvDBID, true)).GetAwaiter().GetResult();
}
using (var upd = Repo.Instance.CrossRef_AniDB_Provider.BeginAddOrUpdate(() => Repo.Instance.CrossRef_AniDB_Provider.GetByAnimeIdAndProvider(CrossRefType.TvDB, cache.AnimeID, cache.CrossRefID)))
{
upd.Entity.CrossRefSource = CrossRefSource.WebCache;
upd.Entity.AnimeID = cache.AnimeID;
upd.Entity.CrossRefID = cache.CrossRefID;
upd.Entity.CrossRefType = CrossRefType.TvDB;
upd.Entity.EpisodesOverrideData = cache.EpisodesOverrideData;
upd.Entity.IsAdditive = cache.IsAdditive;
upd.Commit();
}
}
public static void PopulateFromSeriesInfo(this TvDB_Series series, TvDbSharper.Dto.Series apiSeries)
{
series.SeriesID = 0;
series.Overview = string.Empty;
series.SeriesName = string.Empty;
series.Status = string.Empty;
series.Banner = string.Empty;
series.Fanart = string.Empty;
series.Lastupdated = string.Empty;
series.Poster = string.Empty;
series.SeriesID = apiSeries.Id;
series.SeriesName = apiSeries.SeriesName;
series.Overview = apiSeries.Overview;
series.Banner = apiSeries.Banner;
series.Status = apiSeries.Status;
series.Lastupdated = apiSeries.LastUpdated.ToString();
if (apiSeries.SiteRating != null)
{
series.Rating = (int)Math.Round(apiSeries.SiteRating.Value * 10);
}
}
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 CL_AniDB_AnimeCrossRefs GetCrossRefDetails(int animeID)
{
CL_AniDB_AnimeCrossRefs result = new CL_AniDB_AnimeCrossRefs
{
CrossRef_AniDB_TvDB = new List <CrossRef_AniDB_TvDBV2>(),
TvDBSeries = new List <TvDB_Series>(),
TvDBEpisodes = new List <TvDB_Episode>(),
TvDBImageFanarts = new List <TvDB_ImageFanart>(),
TvDBImagePosters = new List <TvDB_ImagePoster>(),
TvDBImageWideBanners = new List <TvDB_ImageWideBanner>(),
CrossRef_AniDB_MovieDB = null,
MovieDBMovie = null,
MovieDBFanarts = new List <MovieDB_Fanart>(),
MovieDBPosters = new List <MovieDB_Poster>(),
CrossRef_AniDB_MAL = null,
CrossRef_AniDB_Trakt = new List <CrossRef_AniDB_TraktV2>(),
TraktShows = new List <CL_Trakt_Show>(),
AnimeID = animeID
};
try
{
using (var session = DatabaseFactory.SessionFactory.OpenSession())
{
SVR_AniDB_Anime anime = RepoFactory.AniDB_Anime.GetByAnimeID(animeID);
if (anime == null)
{
return(result);
}
var xrefs = RepoFactory.CrossRef_AniDB_TvDB.GetV2LinksFromAnime(animeID);
// TvDB
result.CrossRef_AniDB_TvDB = xrefs;
foreach (TvDB_Episode ep in anime.GetTvDBEpisodes())
{
result.TvDBEpisodes.Add(ep);
}
foreach (var xref in xrefs.DistinctBy(a => a.TvDBID))
{
TvDB_Series ser = RepoFactory.TvDB_Series.GetByTvDBID(xref.TvDBID);
if (ser != null)
{
result.TvDBSeries.Add(ser);
}
foreach (TvDB_ImageFanart fanart in RepoFactory.TvDB_ImageFanart.GetBySeriesID(xref.TvDBID))
{
result.TvDBImageFanarts.Add(fanart);
}
foreach (TvDB_ImagePoster poster in RepoFactory.TvDB_ImagePoster.GetBySeriesID(xref.TvDBID))
{
result.TvDBImagePosters.Add(poster);
}
foreach (TvDB_ImageWideBanner banner in RepoFactory.TvDB_ImageWideBanner.GetBySeriesID(xref
.TvDBID))
{
result.TvDBImageWideBanners.Add(banner);
}
}
// Trakt
foreach (CrossRef_AniDB_TraktV2 xref in anime.GetCrossRefTraktV2(session))
{
result.CrossRef_AniDB_Trakt.Add(xref);
Trakt_Show show = RepoFactory.Trakt_Show.GetByTraktSlug(session, xref.TraktID);
if (show != null)
{
result.TraktShows.Add(show.ToClient());
}
}
// MovieDB
CrossRef_AniDB_Other xrefMovie = anime.GetCrossRefMovieDB();
result.CrossRef_AniDB_MovieDB = xrefMovie;
result.MovieDBMovie = anime.GetMovieDBMovie();
foreach (MovieDB_Fanart fanart in anime.GetMovieDBFanarts())
{
if (fanart.ImageSize.Equals(Shoko.Models.Constants.MovieDBImageSize.Original,
StringComparison.InvariantCultureIgnoreCase))
{
result.MovieDBFanarts.Add(fanart);
}
}
foreach (MovieDB_Poster poster in anime.GetMovieDBPosters())
{
if (poster.ImageSize.Equals(Shoko.Models.Constants.MovieDBImageSize.Original,
StringComparison.InvariantCultureIgnoreCase))
{
result.MovieDBPosters.Add(poster);
}
}
// MAL
List <CrossRef_AniDB_MAL> xrefMAL = anime.GetCrossRefMAL();
if (xrefMAL == null)
{
result.CrossRef_AniDB_MAL = null;
}
else
{
result.CrossRef_AniDB_MAL = new List <CrossRef_AniDB_MAL>();
foreach (CrossRef_AniDB_MAL xrefTemp in xrefMAL)
{
result.CrossRef_AniDB_MAL.Add(xrefTemp);
}
}
}
return(result);
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
return(result);
}
}
public static void MigrateTvDBLinks_V1_to_V2()
{
try
{
using (var session = DatabaseFactory.SessionFactory.OpenSession())
{
ISessionWrapper sessionWrapper = session.Wrap();
IReadOnlyList <CrossRef_AniDB_TvDB> xrefsTvDB = RepoFactory.CrossRef_AniDB_TvDB.GetAll();
foreach (CrossRef_AniDB_TvDB xrefTvDB in xrefsTvDB)
{
CrossRef_AniDB_TvDBV2 xrefNew = new CrossRef_AniDB_TvDBV2
{
AnimeID = xrefTvDB.AnimeID,
CrossRefSource = xrefTvDB.CrossRefSource,
TvDBID = xrefTvDB.TvDBID,
TvDBSeasonNumber = xrefTvDB.TvDBSeasonNumber
};
TvDB_Series ser = xrefTvDB.GetTvDBSeries();
if (ser != null)
{
xrefNew.TvDBTitle = ser.SeriesName;
}
// determine start ep type
if (xrefTvDB.TvDBSeasonNumber == 0)
{
xrefNew.AniDBStartEpisodeType = (int)EpisodeType.Special;
}
else
{
xrefNew.AniDBStartEpisodeType = (int)EpisodeType.Episode;
}
xrefNew.AniDBStartEpisodeNumber = 1;
xrefNew.TvDBStartEpisodeNumber = 1;
RepoFactory.CrossRef_AniDB_TvDBV2.Save(xrefNew);
}
// create cross ref's for specials
foreach (CrossRef_AniDB_TvDB xrefTvDB in xrefsTvDB)
{
SVR_AniDB_Anime anime = RepoFactory.AniDB_Anime.GetByAnimeID(xrefTvDB.AnimeID);
if (anime == null)
{
continue;
}
// this anime has specials
if (anime.EpisodeCountSpecial <= 0)
{
continue;
}
// this tvdb series has a season 0 (specials)
List <int> seasons = RepoFactory.TvDB_Episode.GetSeasonNumbersForSeries(xrefTvDB.TvDBID);
if (!seasons.Contains(0))
{
continue;
}
//make sure we are not doubling up
CrossRef_AniDB_TvDBV2 temp = RepoFactory.CrossRef_AniDB_TvDBV2.GetByTvDBID(xrefTvDB.TvDBID, 0,
1,
xrefTvDB.AnimeID,
(int)EpisodeType.Special, 1);
if (temp != null)
{
continue;
}
CrossRef_AniDB_TvDBV2 xrefNew = new CrossRef_AniDB_TvDBV2
{
AnimeID = xrefTvDB.AnimeID,
CrossRefSource = xrefTvDB.CrossRefSource,
TvDBID = xrefTvDB.TvDBID,
TvDBSeasonNumber = 0,
TvDBStartEpisodeNumber = 1,
AniDBStartEpisodeType = (int)EpisodeType.Special,
AniDBStartEpisodeNumber = 1
};
TvDB_Series ser = xrefTvDB.GetTvDBSeries();
if (ser != null)
{
xrefNew.TvDBTitle = ser.SeriesName;
}
RepoFactory.CrossRef_AniDB_TvDBV2.Save(xrefNew);
}
}
}
catch (Exception ex)
{
logger.Error(ex, "Could not MigrateTvDBLinks_V1_to_V2: " + ex.ToString());
}
}
public static void MigrateTvDBLinks_V1_to_V2()
{
try
{
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
TvDB_EpisodeRepository repEps = new TvDB_EpisodeRepository();
CrossRef_AniDB_TvDBRepository repCrossRefTvDB = new CrossRef_AniDB_TvDBRepository();
CrossRef_AniDB_TvDBV2Repository repCrossRefTvDBNew = new CrossRef_AniDB_TvDBV2Repository();
using (var session = JMMService.SessionFactory.OpenSession())
{
List <CrossRef_AniDB_TvDB> xrefsTvDB = repCrossRefTvDB.GetAll();
foreach (CrossRef_AniDB_TvDB xrefTvDB in xrefsTvDB)
{
CrossRef_AniDB_TvDBV2 xrefNew = new CrossRef_AniDB_TvDBV2();
xrefNew.AnimeID = xrefTvDB.AnimeID;
xrefNew.CrossRefSource = xrefTvDB.CrossRefSource;
xrefNew.TvDBID = xrefTvDB.TvDBID;
xrefNew.TvDBSeasonNumber = xrefTvDB.TvDBSeasonNumber;
TvDB_Series ser = xrefTvDB.GetTvDBSeries(session);
if (ser != null)
{
xrefNew.TvDBTitle = ser.SeriesName;
}
// determine start ep type
if (xrefTvDB.TvDBSeasonNumber == 0)
{
xrefNew.AniDBStartEpisodeType = (int)AniDBAPI.enEpisodeType.Special;
}
else
{
xrefNew.AniDBStartEpisodeType = (int)AniDBAPI.enEpisodeType.Episode;
}
xrefNew.AniDBStartEpisodeNumber = 1;
xrefNew.TvDBStartEpisodeNumber = 1;
repCrossRefTvDBNew.Save(xrefNew);
}
// create cross ref's for specials
foreach (CrossRef_AniDB_TvDB xrefTvDB in xrefsTvDB)
{
AniDB_Anime anime = repAnime.GetByAnimeID(xrefTvDB.AnimeID);
if (anime == null)
{
continue;
}
// this anime has specials
if (anime.EpisodeCountSpecial <= 0)
{
continue;
}
// this tvdb series has a season 0 (specials)
List <int> seasons = repEps.GetSeasonNumbersForSeries(xrefTvDB.TvDBID);
if (!seasons.Contains(0))
{
continue;
}
//make sure we are not doubling up
CrossRef_AniDB_TvDBV2 temp = repCrossRefTvDBNew.GetByTvDBID(xrefTvDB.TvDBID, 0, 1, xrefTvDB.AnimeID, (int)AniDBAPI.enEpisodeType.Special, 1);
if (temp != null)
{
continue;
}
CrossRef_AniDB_TvDBV2 xrefNew = new CrossRef_AniDB_TvDBV2();
xrefNew.AnimeID = xrefTvDB.AnimeID;
xrefNew.CrossRefSource = xrefTvDB.CrossRefSource;
xrefNew.TvDBID = xrefTvDB.TvDBID;
xrefNew.TvDBSeasonNumber = 0;
xrefNew.TvDBStartEpisodeNumber = 1;
xrefNew.AniDBStartEpisodeType = (int)AniDBAPI.enEpisodeType.Special;
xrefNew.AniDBStartEpisodeNumber = 1;
TvDB_Series ser = xrefTvDB.GetTvDBSeries(session);
if (ser != null)
{
xrefNew.TvDBTitle = ser.SeriesName;
}
repCrossRefTvDBNew.Save(xrefNew);
}
}
}
catch (Exception ex)
{
logger.ErrorException("Could not MigrateTvDBLinks_V1_to_V2: " + ex.ToString(), ex);
}
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_TvDBSearchAnime: {0}", AnimeID);
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
// first check if the user wants to use the web cache
if (ServerSettings.WebCache_TvDB_Get)
{
try
{
List <JMMServer.Providers.Azure.CrossRef_AniDB_TvDB> cacheResults =
JMMServer.Providers.Azure.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 (JMMServer.Providers.Azure.CrossRef_AniDB_TvDB xref in cacheResults)
{
TvDB_Series tvser = TvDBHelper.GetSeriesInfoOnline(xref.TvDBID);
if (tvser != null)
{
logger.Trace("Found tvdb match on web cache for {0}", AnimeID);
TvDBHelper.LinkAniDBTvDB(AnimeID,
(AniDBAPI.enEpisodeType)xref.AniDBStartEpisodeType,
xref.AniDBStartEpisodeNumber,
xref.TvDBID, xref.TvDBSeasonNumber,
xref.TvDBStartEpisodeNumber, true);
}
else
{
//if we got a TvDB ID from the web cache, but couldn't find it on TheTvDB.com, it could mean 2 things
//1. thetvdb.com is offline
//2. the id is no longer valid
// if the id is no longer valid we should remove it from the web cache
/*if (TvDBHelper.ConfirmTvDBOnline())
* {
*
* }*/
}
}
return;
}
}
catch (Exception)
{
}
}
string searchCriteria = "";
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 <TVDBSeriesSearchResult> results = JMMService.TvdbHelper.SearchSeries(searchCriteria);
logger.Trace("Found {0} tvdb results for {1} on TheTvDB", results.Count, searchCriteria);
if (ProcessSearchResults(results, searchCriteria))
{
return;
}
if (results.Count == 0)
{
foreach (AniDB_Anime_Title title in anime.GetTitles())
{
if (title.TitleType.ToUpper() != Constants.AnimeTitleType.Official.ToUpper())
{
continue;
}
if (searchCriteria.ToUpper() == title.Title.ToUpper())
{
continue;
}
results = JMMService.TvdbHelper.SearchSeries(title.Title);
logger.Trace("Found {0} tvdb results for search on {1}", results.Count, title.Title);
if (ProcessSearchResults(results, title.Title))
{
return;
}
}
}
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_TvDBSearchAnime: {0} - {1}", AnimeID, ex.ToString());
return;
}
}
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);
}
public static string LinkAniDBTvDB(int animeID, enEpisodeType aniEpType, int aniEpNumber, int tvDBID,
int tvSeasonNumber, int tvEpNumber, bool excludeFromWebCache, bool additiveLink = false)
{
using (var session = DatabaseFactory.SessionFactory.OpenSession())
{
if (!additiveLink)
{
// remove all current links
RemoveAllAniDBTvDBLinks(session.Wrap(), animeID);
}
// check if we have this information locally
// if not download it now
TvDB_Series tvSeries = RepoFactory.TvDB_Series.GetByTvDBID(tvDBID);
if (tvSeries == null)
{
// we download the series info here just so that we have the basic info in the
// database before the queued task runs later
tvSeries = GetSeriesInfoOnline(tvDBID);
}
// download and update series info, episode info and episode images
// will also download fanart, posters and wide banners
CommandRequest_TvDBUpdateSeriesAndEpisodes cmdSeriesEps =
new CommandRequest_TvDBUpdateSeriesAndEpisodes(tvDBID,
false);
//Optimize for batch updates, if there are a lot of LinkAniDBTvDB commands queued
//this will cause only one updateSeriesAndEpisodes command to be created
if (RepoFactory.CommandRequest.GetByCommandID(cmdSeriesEps.CommandID) == null)
{
cmdSeriesEps.Save();
}
CrossRef_AniDB_TvDBV2 xref = RepoFactory.CrossRef_AniDB_TvDBV2.GetByTvDBID(session, tvDBID, tvSeasonNumber, tvEpNumber,
animeID,
(int)aniEpType, aniEpNumber);
if (xref == null)
{
xref = new CrossRef_AniDB_TvDBV2();
}
xref.AnimeID = animeID;
xref.AniDBStartEpisodeType = (int)aniEpType;
xref.AniDBStartEpisodeNumber = aniEpNumber;
xref.TvDBID = tvDBID;
xref.TvDBSeasonNumber = tvSeasonNumber;
xref.TvDBStartEpisodeNumber = tvEpNumber;
if (tvSeries != null)
{
xref.TvDBTitle = tvSeries.SeriesName;
}
if (excludeFromWebCache)
{
xref.CrossRefSource = (int)CrossRefSource.WebCache;
}
else
{
xref.CrossRefSource = (int)CrossRefSource.User;
}
RepoFactory.CrossRef_AniDB_TvDBV2.Save(xref);
AniDB_Anime.UpdateStatsByAnimeID(animeID);
logger.Trace("Changed tvdb association: {0}", animeID);
if (!excludeFromWebCache)
{
CommandRequest_WebCacheSendXRefAniDBTvDB req =
new CommandRequest_WebCacheSendXRefAniDBTvDB(xref.CrossRef_AniDB_TvDBV2ID);
req.Save();
}
if (ServerSettings.Trakt_IsEnabled && !string.IsNullOrEmpty(ServerSettings.Trakt_AuthToken))
{
if (RepoFactory.CrossRef_AniDB_TraktV2.GetByAnimeID(animeID).Count == 0)
{
// check for Trakt associations
CommandRequest_TraktSearchAnime cmd2 = new CommandRequest_TraktSearchAnime(animeID, false);
cmd2.Save(session);
}
}
}
return("");
}
/// <summary>
/// Updates the followung
/// 1. Series Info
/// 2. Episode Info
/// 3. Episode Images
/// 4. Fanart, Poster and Wide Banner Images
/// </summary>
/// <param name="seriesID"></param>
/// <param name="forceRefresh"></param>
public void UpdateAllInfoAndImages(int seriesID, bool forceRefresh, bool downloadImages)
{
string fileName = string.Format("{0}.xml", ServerSettings.TvDB_Language);
Dictionary <string, XmlDocument> docSeries = GetFullSeriesInfo(seriesID);
if (docSeries.ContainsKey(fileName))
{
try
{
// update the series info
XmlDocument xmlDoc = docSeries[fileName];
if (xmlDoc != null)
{
TvDB_Series tvSeries = RepoFactory.TvDB_Series.GetByTvDBID(seriesID);
if (tvSeries == null)
{
tvSeries = new TvDB_Series();
}
tvSeries.PopulateFromSeriesInfo(xmlDoc);
RepoFactory.TvDB_Series.Save(tvSeries);
}
if (downloadImages)
{
// get all fanart, posters and wide banners
if (docSeries.ContainsKey("banners.xml"))
{
XmlDocument xmlDocBanners = docSeries["banners.xml"];
if (xmlDocBanners != null)
{
DownloadAutomaticImages(xmlDocBanners, seriesID, forceRefresh);
}
}
}
// update all the episodes and download episode images
XmlNodeList episodeItems = xmlDoc["Data"].GetElementsByTagName("Episode");
logger.Trace("Found {0} Episode nodes", episodeItems.Count.ToString());
List <int> existingEpIds = new List <int>();
foreach (XmlNode node in episodeItems)
{
try
{
// the episode id
int id = int.Parse(node["id"].InnerText.Trim());
existingEpIds.Add(id);
TvDB_Episode ep = RepoFactory.TvDB_Episode.GetByTvDBID(id);
if (ep == null)
{
ep = new TvDB_Episode();
}
ep.Populate(node);
RepoFactory.TvDB_Episode.Save(ep);
//BaseConfig.MyAnimeLog.Write("Refreshing episode info for: {0}", ep.ToString());
if (downloadImages)
{
// download the image for this episode
if (!string.IsNullOrEmpty(ep.Filename))
{
bool fileExists = File.Exists(ep.FullImagePath);
if (!fileExists || (fileExists && forceRefresh))
{
CommandRequest_DownloadImage cmd =
new CommandRequest_DownloadImage(ep.TvDB_EpisodeID,
JMMImageType.TvDB_Episode, forceRefresh);
cmd.Save();
}
}
}
}
catch (Exception ex)
{
logger.Error(ex, "Error in TVDBHelper.GetEpisodes: " + ex.ToString());
}
}
// get all the existing tvdb episodes, to see if any have been deleted
List <TvDB_Episode> allEps = RepoFactory.TvDB_Episode.GetBySeriesID(seriesID);
foreach (TvDB_Episode oldEp in allEps)
{
if (!existingEpIds.Contains(oldEp.Id))
{
RepoFactory.TvDB_Episode.Delete(oldEp.TvDB_EpisodeID);
}
}
}
catch (Exception ex)
{
logger.Error(ex, "Error in TVDBHelper.GetEpisodes: " + ex.ToString());
}
}
}
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);
}
}
