public override void ProcessCommand()
{
try
{
CrossRef_AniDB_TraktV2Repository repCrossRef = new CrossRef_AniDB_TraktV2Repository();
CrossRef_AniDB_TraktV2 xref = repCrossRef.GetByID(CrossRef_AniDB_TraktID);
if (xref == null) return;
Trakt_ShowRepository repShow = new Trakt_ShowRepository();
Trakt_Show tvShow = repShow.GetByTraktSlug(xref.TraktID);
if (tvShow == null) return;
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(xref.AnimeID);
if (anime == null) return;
string showName = "";
if (tvShow != null) showName = tvShow.Title;
AzureWebAPI.Send_CrossRefAniDBTrakt(xref, anime.MainTitle);
}
catch (Exception ex)
{
logger.ErrorException("Error processing CommandRequest_WebCacheSendXRefAniDBTrakt: {0}" + ex.ToString(), ex);
return;
}
}
private void PopulateCrossRefs()
{
try
{
CrossRef_AniDB_TraktV2Repository repCrossRef = new CrossRef_AniDB_TraktV2Repository();
crossRefTraktV2 = repCrossRef.GetByAnimeID(AnimeID);
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
}
public static void RemoveLinkAniDBTrakt(int animeID, enEpisodeType aniEpType, int aniEpNumber, string traktID, int seasonNumber, int traktEpNumber)
{
CrossRef_AniDB_TraktV2Repository repCrossRef = new CrossRef_AniDB_TraktV2Repository();
CrossRef_AniDB_TraktV2 xref = repCrossRef.GetByTraktID(traktID, seasonNumber, traktEpNumber, animeID, (int)aniEpType, aniEpNumber);
if (xref == null) return;
repCrossRef.Delete(xref.CrossRef_AniDB_TraktV2ID);
StatsCache.Instance.UpdateUsingAnime(animeID);
if (ServerSettings.WebCache_Trakt_Send)
{
CommandRequest_WebCacheDeleteXRefAniDBTrakt req = new CommandRequest_WebCacheDeleteXRefAniDBTrakt(animeID, (int)aniEpType, aniEpNumber,
traktID, seasonNumber, traktEpNumber);
req.Save();
}
}
public static string LinkAniDBTrakt(ISession session, int animeID, enEpisodeType aniEpType, int aniEpNumber, string traktID, int seasonNumber, int traktEpNumber, bool excludeFromWebCache)
{
CrossRef_AniDB_TraktV2Repository repCrossRef = new CrossRef_AniDB_TraktV2Repository();
List<CrossRef_AniDB_TraktV2> xrefTemps = repCrossRef.GetByAnimeIDEpTypeEpNumber(session, animeID, (int)aniEpType, aniEpNumber);
if (xrefTemps != null && xrefTemps.Count > 0)
{
foreach (CrossRef_AniDB_TraktV2 xrefTemp in xrefTemps)
{
// delete the existing one if we are updating
TraktTVHelper.RemoveLinkAniDBTrakt(xrefTemp.AnimeID, (enEpisodeType)xrefTemp.AniDBStartEpisodeType, xrefTemp.AniDBStartEpisodeNumber,
xrefTemp.TraktID, xrefTemp.TraktSeasonNumber, xrefTemp.TraktStartEpisodeNumber);
}
}
// check if we have this information locally
// if not download it now
Trakt_ShowRepository repSeries = new Trakt_ShowRepository();
Trakt_Show traktShow = repSeries.GetByTraktSlug(traktID);
if (traktShow == null)
{
// we download the series info here just so that we have the basic info in the
// database before the queued task runs later
TraktV2ShowExtended tvshow = GetShowInfoV2(traktID);
}
// download and update series info, episode info and episode images
// will also download fanart, posters and wide banners
// download fanart, posters
DownloadAllImages(traktID);
CrossRef_AniDB_TraktV2 xref = repCrossRef.GetByTraktID(session, traktID, seasonNumber, traktEpNumber, animeID, (int)aniEpType, aniEpNumber);
if (xref == null)
xref = new CrossRef_AniDB_TraktV2();
xref.AnimeID = animeID;
xref.AniDBStartEpisodeType = (int)aniEpType;
xref.AniDBStartEpisodeNumber = aniEpNumber;
xref.TraktID = traktID;
xref.TraktSeasonNumber = seasonNumber;
xref.TraktStartEpisodeNumber = traktEpNumber;
if (traktShow != null)
xref.TraktTitle = traktShow.Title;
if (excludeFromWebCache)
xref.CrossRefSource = (int)CrossRefSource.WebCache;
else
xref.CrossRefSource = (int)CrossRefSource.User;
repCrossRef.Save(xref);
StatsCache.Instance.UpdateUsingAnime(animeID);
logger.Trace("Changed trakt association: {0}", animeID);
if (!excludeFromWebCache && ServerSettings.WebCache_Trakt_Send)
{
CommandRequest_WebCacheSendXRefAniDBTrakt req = new CommandRequest_WebCacheSendXRefAniDBTrakt(xref.CrossRef_AniDB_TraktV2ID);
req.Save();
}
return "";
}
public static List<TraktV2Comment> GetShowCommentsV2(ISession session, int animeID)
{
List<TraktV2Comment> ret = new List<TraktV2Comment>();
try
{
if (!ServerSettings.Trakt_IsEnabled || string.IsNullOrEmpty(ServerSettings.Trakt_AuthToken))
return ret;
CrossRef_AniDB_TraktV2Repository repXrefTrakt = new CrossRef_AniDB_TraktV2Repository();
List<CrossRef_AniDB_TraktV2> traktXRefs = repXrefTrakt.GetByAnimeID(session, animeID);
if (traktXRefs == null || traktXRefs.Count == 0) return null;
// get a unique list of trakt id's
List<string> ids = new List<string>();
foreach (CrossRef_AniDB_TraktV2 xref in traktXRefs)
{
if (!ids.Contains(xref.TraktID))
ids.Add(xref.TraktID);
}
foreach (string id in ids)
{
bool morePages = true;
int curPage = 0;
while (morePages)
{
curPage++;
string url = string.Format(TraktURIs.ShowComments, id, curPage, TraktConstants.PaginationLimit);
logger.Trace("GetShowComments: {0}", url);
string json = GetFromTrakt(url);
if (string.IsNullOrEmpty(json))
return null;
var resultComments = json.FromJSONArray<TraktV2Comment>();
if (resultComments != null)
{
List<TraktV2Comment> thisComments = new List<TraktV2Comment>(resultComments);
ret.AddRange(thisComments);
if (thisComments.Count == TraktConstants.PaginationLimit)
morePages = true;
else
morePages = false;
}
else
morePages = false;
}
}
}
catch (Exception ex)
{
logger.ErrorException("Error in TraktTVHelper.GetShowComments: " + ex.ToString(), ex);
}
return ret;
}
public static void UpdateAllInfo()
{
CrossRef_AniDB_TraktV2Repository repCrossRef = new CrossRef_AniDB_TraktV2Repository();
List<CrossRef_AniDB_TraktV2> allCrossRefs = repCrossRef.GetAll();
foreach (CrossRef_AniDB_TraktV2 xref in allCrossRefs)
{
CommandRequest_TraktUpdateInfoAndImages cmd = new CommandRequest_TraktUpdateInfoAndImages(xref.TraktID);
cmd.Save();
}
}
public static void SyncCollectionToTrakt()
{
try
{
if (!ServerSettings.Trakt_IsEnabled || string.IsNullOrEmpty(ServerSettings.Trakt_AuthToken)) return;
// check that we have at least one user nominated for Trakt
JMMUserRepository repUsers = new JMMUserRepository();
List<JMMUser> traktUsers = repUsers.GetTraktUsers();
if (traktUsers.Count == 0) return;
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
List<AnimeSeries> allSeries = repSeries.GetAll();
// now get the full users collection from Trakt
List<TraktV2ShowCollectedResult> collected = new List<TraktV2ShowCollectedResult>();
List<TraktV2ShowWatchedResult> watched = new List<TraktV2ShowWatchedResult>();
if (!GetTraktCollectionInfo(ref collected, ref watched)) return;
TraktV2SyncCollectionEpisodesByNumber syncCollectionAdd = new TraktV2SyncCollectionEpisodesByNumber();
TraktV2SyncCollectionEpisodesByNumber syncCollectionRemove = new TraktV2SyncCollectionEpisodesByNumber();
TraktV2SyncWatchedEpisodesByNumber syncHistoryAdd = new TraktV2SyncWatchedEpisodesByNumber();
TraktV2SyncWatchedEpisodesByNumber syncHistoryRemove = new TraktV2SyncWatchedEpisodesByNumber();
#region Local Collection Sync
///////////////////////////////////////////////////////////////////////////////////////
// First take a look at our local collection and update on Trakt
///////////////////////////////////////////////////////////////////////////////////////
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
int counter = 0;
foreach (AnimeSeries series in allSeries)
{
counter++;
logger.Trace("Syncing check - local collection: {0} / {1} - {2}", counter, allSeries.Count, series.GetSeriesName());
AniDB_Anime anime = repAnime.GetByAnimeID(series.AniDB_ID);
if (anime == null) continue;
//if (anime.AnimeID != 3427) continue;
TraktSummaryContainer traktSummary = new TraktSummaryContainer();
traktSummary.Populate(series.AniDB_ID);
if (traktSummary.CrossRefTraktV2 == null || traktSummary.CrossRefTraktV2.Count == 0) continue;
// get the current watched records for this series on Trakt
foreach (AnimeEpisode ep in series.GetAnimeEpisodes())
{
if (ep.EpisodeTypeEnum == enEpisodeType.Episode || ep.EpisodeTypeEnum == enEpisodeType.Special)
{
EpisodeSyncDetails epsync = ReconSyncTraktEpisode(series, ep, traktSummary, traktUsers, collected, watched, false);
if (epsync != null)
{
switch (epsync.SyncType)
{
case TraktSyncType.CollectionAdd:
syncCollectionAdd.AddEpisode(epsync.Slug, epsync.Season, epsync.EpNumber, epsync.EpDate); break;
case TraktSyncType.CollectionRemove:
syncCollectionRemove.AddEpisode(epsync.Slug, epsync.Season, epsync.EpNumber, epsync.EpDate); break;
case TraktSyncType.HistoryAdd:
syncHistoryAdd.AddEpisode(epsync.Slug, epsync.Season, epsync.EpNumber, epsync.EpDate); break;
case TraktSyncType.HistoryRemove:
syncHistoryRemove.AddEpisode(epsync.Slug, epsync.Season, epsync.EpNumber, epsync.EpDate); break;
}
}
}
}
}
#endregion
// refresh online info, just in case it was chnaged by the last operations
if (!GetTraktCollectionInfo(ref collected, ref watched)) return;
#region Online Collection Sync
///////////////////////////////////////////////////////////////////////////////////////
// Now look at the collection according to Trakt, and remove it if we don't have it locally
///////////////////////////////////////////////////////////////////////////////////////
CrossRef_AniDB_TraktV2Repository repCrossRef = new CrossRef_AniDB_TraktV2Repository();
counter = 0;
foreach (TraktV2ShowCollectedResult col in collected)
{
counter++;
logger.Trace("Syncing check - Online collection: {0} / {1} - {2}", counter, collected.Count, col.show.Title);
//continue;
// check if we have this series locally
List<CrossRef_AniDB_TraktV2> xrefs = repCrossRef.GetByTraktID(col.show.ids.slug);
if (xrefs.Count > 0)
{
foreach (CrossRef_AniDB_TraktV2 xref in xrefs)
{
AnimeSeries locSeries = repSeries.GetByAnimeID(xref.AnimeID);
if (locSeries == null) continue;
TraktSummaryContainer traktSummary = new TraktSummaryContainer();
traktSummary.Populate(locSeries.AniDB_ID);
if (traktSummary.CrossRefTraktV2 == null || traktSummary.CrossRefTraktV2.Count == 0) continue;
// if we have this series locSeries, let's sync the whole series
foreach (AnimeEpisode ep in locSeries.GetAnimeEpisodes())
{
if (ep.EpisodeTypeEnum == enEpisodeType.Episode || ep.EpisodeTypeEnum == enEpisodeType.Special)
{
EpisodeSyncDetails epsync = ReconSyncTraktEpisode(locSeries, ep, traktSummary, traktUsers, collected, watched, false);
if (epsync != null)
{
switch (epsync.SyncType)
{
case TraktSyncType.CollectionAdd:
syncCollectionAdd.AddEpisode(epsync.Slug, epsync.Season, epsync.EpNumber, epsync.EpDate); break;
case TraktSyncType.CollectionRemove:
syncCollectionRemove.AddEpisode(epsync.Slug, epsync.Season, epsync.EpNumber, epsync.EpDate); break;
case TraktSyncType.HistoryAdd:
syncHistoryAdd.AddEpisode(epsync.Slug, epsync.Season, epsync.EpNumber, epsync.EpDate); break;
case TraktSyncType.HistoryRemove:
syncHistoryRemove.AddEpisode(epsync.Slug, epsync.Season, epsync.EpNumber, epsync.EpDate); break;
}
}
}
}
}
}
else
{
// Actually we can't do this, because the user may have other non Anime series and Movies
/*
// series doesn't exist locally at all, so let's completely remove it from Trakt
foreach (TraktV2CollectedSeason colSeason in col.seasons)
{
foreach (TraktV2CollectedEpisode colEp in colSeason.episodes)
{
string msg = string.Format("SYNC ONLINE: Removing from Trakt Collection: Slug: {0} - S:{1} - EP:{2}", col.show.ids.slug, colSeason.number, colEp.number);
logger.Trace(msg);
SyncEpisodeToTrakt(TraktSyncType.CollectionRemove, col.show.ids.slug, colSeason.number, colEp.number, DateTime.Now, false);
}
}*/
}
}
#endregion
// refresh online info, just in case it was chnaged by the last operations
if (!GetTraktCollectionInfo(ref collected, ref watched)) return;
#region Online History (Watched/Unwatched) Sync
///////////////////////////////////////////////////////////////////////////////////////
// Now look at the history according to Trakt, and remove it if we don't have it locally
///////////////////////////////////////////////////////////////////////////////////////
counter = 0;
foreach (TraktV2ShowWatchedResult wtch in watched)
{
counter++;
logger.Trace("Syncing check - Online History: {0} / {1} - {2}", counter, watched.Count, wtch.show.Title);
//continue;
// check if we have this series locally
List<CrossRef_AniDB_TraktV2> xrefs = repCrossRef.GetByTraktID(wtch.show.ids.slug);
if (xrefs.Count > 0)
{
foreach (CrossRef_AniDB_TraktV2 xref in xrefs)
{
AnimeSeries locSeries = repSeries.GetByAnimeID(xref.AnimeID);
if (locSeries == null) continue;
TraktSummaryContainer traktSummary = new TraktSummaryContainer();
traktSummary.Populate(locSeries.AniDB_ID);
if (traktSummary.CrossRefTraktV2 == null || traktSummary.CrossRefTraktV2.Count == 0) continue;
// if we have this series locSeries, let's sync the whole series
foreach (AnimeEpisode ep in locSeries.GetAnimeEpisodes())
{
if (ep.EpisodeTypeEnum == enEpisodeType.Episode || ep.EpisodeTypeEnum == enEpisodeType.Special)
{
EpisodeSyncDetails epsync = ReconSyncTraktEpisode(locSeries, ep, traktSummary, traktUsers, collected, watched, false);
if (epsync != null)
{
switch (epsync.SyncType)
{
case TraktSyncType.CollectionAdd:
syncCollectionAdd.AddEpisode(epsync.Slug, epsync.Season, epsync.EpNumber, epsync.EpDate); break;
case TraktSyncType.CollectionRemove:
syncCollectionRemove.AddEpisode(epsync.Slug, epsync.Season, epsync.EpNumber, epsync.EpDate); break;
case TraktSyncType.HistoryAdd:
syncHistoryAdd.AddEpisode(epsync.Slug, epsync.Season, epsync.EpNumber, epsync.EpDate); break;
case TraktSyncType.HistoryRemove:
syncHistoryRemove.AddEpisode(epsync.Slug, epsync.Season, epsync.EpNumber, epsync.EpDate); break;
}
}
}
}
}
}
else
{
// Actually we can't do this, because the user may have other non Anime series and Movies
/*
// series doesn't exist locally at all, so let's completely remove it from Trakt
foreach (TraktV2WatchedSeason wtchSeason in wtch.seasons)
{
foreach (TraktV2WatchedEpisode wtchEp in wtchSeason.episodes)
{
string msg = string.Format("SYNC ONLINE: Removing from Trakt History: Slug: {0} - S:{1} - EP:{2}", wtch.show.ids.slug, wtchSeason.number, wtchEp.number);
logger.Trace(msg);
SyncEpisodeToTrakt(TraktSyncType.HistoryRemove, wtch.show.ids.slug, wtchSeason.number, wtchEp.number, DateTime.Now, false);
}
}*/
}
}
#endregion
// send the data to Trakt
string json = string.Empty;
string url = TraktURIs.SyncCollectionAdd;
string retData = string.Empty;
if (syncCollectionAdd.shows != null && syncCollectionAdd.shows.Count > 0)
{
json = JSONHelper.Serialize<TraktV2SyncCollectionEpisodesByNumber>(syncCollectionAdd);
url = TraktURIs.SyncCollectionAdd;
retData = string.Empty;
SendData(url, json, "POST", BuildRequestHeaders(), ref retData);
}
if (syncCollectionRemove.shows != null && syncCollectionRemove.shows.Count > 0)
{
json = JSONHelper.Serialize<TraktV2SyncCollectionEpisodesByNumber>(syncCollectionRemove);
url = TraktURIs.SyncCollectionRemove;
retData = string.Empty;
SendData(url, json, "POST", BuildRequestHeaders(), ref retData);
}
if (syncHistoryAdd.shows != null && syncHistoryAdd.shows.Count > 0)
{
json = JSONHelper.Serialize<TraktV2SyncWatchedEpisodesByNumber>(syncHistoryAdd);
url = TraktURIs.SyncHistoryAdd;
retData = string.Empty;
SendData(url, json, "POST", BuildRequestHeaders(), ref retData);
}
if (syncHistoryRemove.shows != null && syncHistoryRemove.shows.Count > 0)
{
json = JSONHelper.Serialize<TraktV2SyncWatchedEpisodesByNumber>(syncHistoryRemove);
url = TraktURIs.SyncHistoryRemove;
retData = string.Empty;
SendData(url, json, "POST", BuildRequestHeaders(), ref retData);
}
logger.Trace("Test");
}
catch (Exception ex)
{
logger.ErrorException("Error in TraktTVHelper.SyncCollectionToTrakt: " + ex.ToString(), ex);
}
}
public static string LinkAniDBTvDB(int animeID, enEpisodeType aniEpType, int aniEpNumber, int tvDBID, int tvSeasonNumber, int tvEpNumber, bool excludeFromWebCache)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
CrossRef_AniDB_TvDBV2Repository repCrossRef = new CrossRef_AniDB_TvDBV2Repository();
List<CrossRef_AniDB_TvDBV2> xrefTemps = repCrossRef.GetByAnimeIDEpTypeEpNumber(session, animeID, (int)aniEpType, aniEpNumber);
if (xrefTemps != null && xrefTemps.Count > 0)
{
foreach (CrossRef_AniDB_TvDBV2 xrefTemp in xrefTemps)
{
// delete the existing one if we are updating
TvDBHelper.RemoveLinkAniDBTvDB(xrefTemp.AnimeID, (enEpisodeType)xrefTemp.AniDBStartEpisodeType, xrefTemp.AniDBStartEpisodeNumber,
xrefTemp.TvDBID, xrefTemp.TvDBSeasonNumber, xrefTemp.TvDBStartEpisodeNumber);
}
}
// check if we have this information locally
// if not download it now
TvDB_SeriesRepository repSeries = new TvDB_SeriesRepository();
TvDB_Series tvSeries = repSeries.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);
cmdSeriesEps.Save();
CrossRef_AniDB_TvDBV2 xref = repCrossRef.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;
repCrossRef.Save(xref);
StatsCache.Instance.UpdateUsingAnime(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))
{
CrossRef_AniDB_TraktV2Repository repTraktXrefs = new CrossRef_AniDB_TraktV2Repository();
if (repTraktXrefs.GetByAnimeID(animeID).Count == 0)
{
// check for Trakt associations
CommandRequest_TraktSearchAnime cmd2 = new CommandRequest_TraktSearchAnime(animeID, false);
cmd2.Save(session);
}
}
}
return "";
}
public List<CrossRef_AniDB_TraktV2> GetCrossRefTraktV2(ISession session)
{
CrossRef_AniDB_TraktV2Repository repCrossRef = new CrossRef_AniDB_TraktV2Repository();
return repCrossRef.GetByAnimeID(session, this.AnimeID);
}
public string RemoveLinkAniDBTraktForAnime(int animeID)
{
try
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries ser = repSeries.GetByAnimeID(animeID);
if (ser == null) return "Could not find Series for Anime!";
// check if there are default images used associated
AniDB_Anime_DefaultImageRepository repDefaults = new AniDB_Anime_DefaultImageRepository();
List<AniDB_Anime_DefaultImage> images = repDefaults.GetByAnimeID(animeID);
foreach (AniDB_Anime_DefaultImage image in images)
{
if (image.ImageParentType == (int)JMMImageType.Trakt_Fanart ||
image.ImageParentType == (int)JMMImageType.Trakt_Poster)
{
repDefaults.Delete(image.AniDB_Anime_DefaultImageID);
}
}
CrossRef_AniDB_TraktV2Repository repXrefTrakt = new CrossRef_AniDB_TraktV2Repository();
foreach (CrossRef_AniDB_TraktV2 xref in repXrefTrakt.GetByAnimeID(animeID))
{
TraktTVHelper.RemoveLinkAniDBTrakt(animeID, (enEpisodeType)xref.AniDBStartEpisodeType, xref.AniDBStartEpisodeNumber,
xref.TraktID, xref.TraktSeasonNumber, xref.TraktStartEpisodeNumber);
}
return "";
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
}
public string LinkAniDBTrakt(int animeID, int aniEpType, int aniEpNumber, string traktID, int seasonNumber, int traktEpNumber, int? crossRef_AniDB_TraktV2ID)
{
try
{
CrossRef_AniDB_TraktV2Repository repXref = new CrossRef_AniDB_TraktV2Repository();
if (crossRef_AniDB_TraktV2ID.HasValue)
{
CrossRef_AniDB_TraktV2 xrefTemp = repXref.GetByID(crossRef_AniDB_TraktV2ID.Value);
// delete the existing one if we are updating
TraktTVHelper.RemoveLinkAniDBTrakt(xrefTemp.AnimeID, (enEpisodeType)xrefTemp.AniDBStartEpisodeType, xrefTemp.AniDBStartEpisodeNumber,
xrefTemp.TraktID, xrefTemp.TraktSeasonNumber, xrefTemp.TraktStartEpisodeNumber);
}
CrossRef_AniDB_TraktV2 xref = repXref.GetByTraktID(traktID, seasonNumber, traktEpNumber, animeID, aniEpType, aniEpNumber);
if (xref != null)
{
string msg = string.Format("You have already linked Anime ID {0} to this Trakt show/season/ep", xref.AnimeID);
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(xref.AnimeID);
if (anime != null)
{
msg = string.Format("You have already linked Anime {0} ({1}) to this Trakt show/season/ep", anime.MainTitle, xref.AnimeID);
}
return msg;
}
return TraktTVHelper.LinkAniDBTrakt(animeID, (enEpisodeType)aniEpType, aniEpNumber, traktID, seasonNumber, traktEpNumber, false);
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
}
public List<Contract_CrossRef_AniDB_TraktV2> GetTraktCrossRefV2(int animeID)
{
try
{
List<Contract_CrossRef_AniDB_TraktV2> contracts = new List<Contract_CrossRef_AniDB_TraktV2>();
CrossRef_AniDB_TraktV2Repository repCrossRef = new CrossRef_AniDB_TraktV2Repository();
List<CrossRef_AniDB_TraktV2> xrefs = repCrossRef.GetByAnimeID(animeID);
if (xrefs == null) return contracts;
foreach (CrossRef_AniDB_TraktV2 xref in xrefs)
contracts.Add(xref.ToContract());
return contracts;
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return null;
}
}
public List<Contract_CrossRef_AniDB_TraktV2> GetAllTraktCrossRefs()
{
List<Contract_CrossRef_AniDB_TraktV2> contracts = new List<Contract_CrossRef_AniDB_TraktV2>();
try
{
CrossRef_AniDB_TraktV2Repository repCrossRef = new CrossRef_AniDB_TraktV2Repository();
List<CrossRef_AniDB_TraktV2> allCrossRefs = repCrossRef.GetAll();
foreach (CrossRef_AniDB_TraktV2 xref in allCrossRefs)
{
contracts.Add(xref.ToContract());
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return contracts;
}
public static void MigrateTraktLinks_V1_to_V2()
{
try
{
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
Trakt_EpisodeRepository repEps = new Trakt_EpisodeRepository();
Trakt_ShowRepository repShows = new Trakt_ShowRepository();
CrossRef_AniDB_TraktRepository repCrossRefTrakt = new CrossRef_AniDB_TraktRepository();
CrossRef_AniDB_TraktV2Repository repCrossRefTraktNew = new CrossRef_AniDB_TraktV2Repository();
using (var session = JMMService.SessionFactory.OpenSession())
{
List<CrossRef_AniDB_Trakt> xrefsTrakt = repCrossRefTrakt.GetAll();
foreach (CrossRef_AniDB_Trakt xrefTrakt in xrefsTrakt)
{
CrossRef_AniDB_TraktV2 xrefNew = new CrossRef_AniDB_TraktV2();
xrefNew.AnimeID = xrefTrakt.AnimeID;
xrefNew.CrossRefSource = xrefTrakt.CrossRefSource;
xrefNew.TraktID = xrefTrakt.TraktID;
xrefNew.TraktSeasonNumber = xrefTrakt.TraktSeasonNumber;
Trakt_Show show = xrefTrakt.GetByTraktShow(session);
if (show != null)
xrefNew.TraktTitle = show.Title;
// determine start ep type
if (xrefTrakt.TraktSeasonNumber == 0)
xrefNew.AniDBStartEpisodeType = (int)AniDBAPI.enEpisodeType.Special;
else
xrefNew.AniDBStartEpisodeType = (int)AniDBAPI.enEpisodeType.Episode;
xrefNew.AniDBStartEpisodeNumber = 1;
xrefNew.TraktStartEpisodeNumber = 1;
repCrossRefTraktNew.Save(xrefNew);
}
// create cross ref's for specials
foreach (CrossRef_AniDB_Trakt xrefTrakt in xrefsTrakt)
{
AniDB_Anime anime = repAnime.GetByAnimeID(xrefTrakt.AnimeID);
if (anime == null) continue;
Trakt_Show show = xrefTrakt.GetByTraktShow(session);
if (show == null) continue;
// this anime has specials
if (anime.EpisodeCountSpecial <= 0) continue;
// this Trakt series has a season 0 (specials)
List<int> seasons = repEps.GetSeasonNumbersForSeries(show.Trakt_ShowID);
if (!seasons.Contains(0)) continue;
//make sure we are not doubling up
CrossRef_AniDB_TraktV2 temp = repCrossRefTraktNew.GetByTraktID(xrefTrakt.TraktID, 0, 1, xrefTrakt.AnimeID, (int)AniDBAPI.enEpisodeType.Special, 1);
if (temp != null) continue;
CrossRef_AniDB_TraktV2 xrefNew = new CrossRef_AniDB_TraktV2();
xrefNew.AnimeID = xrefTrakt.AnimeID;
xrefNew.CrossRefSource = xrefTrakt.CrossRefSource;
xrefNew.TraktID = xrefTrakt.TraktID;
xrefNew.TraktSeasonNumber = 0;
xrefNew.TraktStartEpisodeNumber = 1;
xrefNew.AniDBStartEpisodeType = (int)AniDBAPI.enEpisodeType.Special;
xrefNew.AniDBStartEpisodeNumber = 1;
xrefNew.TraktTitle = show.Title;
repCrossRefTraktNew.Save(xrefNew);
}
}
}
catch (Exception ex)
{
logger.ErrorException("Could not MigrateTraktLinks_V1_to_V2: " + ex.ToString(), ex);
}
}
public static void RemoveTraktDBEntries(Trakt_Show show)
{
Trakt_ShowRepository repShows = new Trakt_ShowRepository();
CrossRef_AniDB_TraktV2Repository repXRefs = new CrossRef_AniDB_TraktV2Repository();
Trakt_ImageFanartRepository repFanart = new Trakt_ImageFanartRepository();
Trakt_SeasonRepository repSeasons = new Trakt_SeasonRepository();
Trakt_EpisodeRepository repEpisodes = new Trakt_EpisodeRepository();
Trakt_ImagePosterRepository repPosters = new Trakt_ImagePosterRepository();
// this means Trakt has no record of this slug.
// 1. Delete any cross ref links
foreach (CrossRef_AniDB_TraktV2 xref in repXRefs.GetByTraktID(show.TraktID))
repXRefs.Delete(xref.CrossRef_AniDB_TraktV2ID);
// 2. Delete default image links
// 3. Delete episodes
foreach (Trakt_Episode epTemp in repEpisodes.GetByShowID(show.Trakt_ShowID))
repEpisodes.Delete(epTemp.Trakt_EpisodeID);
// 4. Delete fanart and posters
foreach (Trakt_ImageFanart fanart in repFanart.GetByShowID(show.Trakt_ShowID))
repFanart.Delete(fanart.Trakt_ImageFanartID);
foreach (Trakt_ImagePoster poster in repPosters.GetByShowID(show.Trakt_ShowID))
repPosters.Delete(poster.Trakt_ImagePosterID);
// 5. Delete seasons
foreach (Trakt_Season season in repSeasons.GetByShowID(show.Trakt_ShowID))
repSeasons.Delete(season.Trakt_SeasonID);
// 6. Delete the show
repShows.Delete(show.Trakt_ShowID);
}
public static void ScanForMatches()
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
List<AnimeSeries> allSeries = repSeries.GetAll();
CrossRef_AniDB_TraktV2Repository repCrossRef = new CrossRef_AniDB_TraktV2Repository();
List<CrossRef_AniDB_TraktV2> allCrossRefs = repCrossRef.GetAll();
List<int> alreadyLinked = new List<int>();
foreach (CrossRef_AniDB_TraktV2 xref in allCrossRefs)
{
alreadyLinked.Add(xref.AnimeID);
}
foreach (AnimeSeries ser in allSeries)
{
if (alreadyLinked.Contains(ser.AniDB_ID)) continue;
AniDB_Anime anime = ser.GetAnime();
if (anime != null)
logger.Trace("Found anime without Trakt association: " + anime.MainTitle);
if (anime.IsTraktLinkDisabled) continue;
CommandRequest_TraktSearchAnime cmd = new CommandRequest_TraktSearchAnime(ser.AniDB_ID, false);
cmd.Save();
}
}
/// <summary>
/// Sends the current user's Trakt links to the web cache, and then admin approves them
/// </summary>
/// <returns></returns>
public string UseMyTraktLinksWebCache(int animeID)
{
try
{
// Get all the links for this user and anime
CrossRef_AniDB_TraktV2Repository repCrossRef = new CrossRef_AniDB_TraktV2Repository();
List<CrossRef_AniDB_TraktV2> xrefs = repCrossRef.GetByAnimeID(animeID);
if (xrefs == null) return "No Links found to use";
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(animeID);
if (anime == null) return "Anime not found";
// make sure the user doesn't alreday have links
List<JMMServer.Providers.Azure.CrossRef_AniDB_Trakt> results = JMMServer.Providers.Azure.AzureWebAPI.Admin_Get_CrossRefAniDBTrakt(animeID);
bool foundLinks = false;
if (results != null)
{
foreach (JMMServer.Providers.Azure.CrossRef_AniDB_Trakt xref in results)
{
if (xref.Username.Equals(ServerSettings.AniDB_Username, StringComparison.InvariantCultureIgnoreCase))
{
foundLinks = true;
break;
}
}
}
if (foundLinks) return "Links already exist, please approve them instead";
// send the links to the web cache
foreach (CrossRef_AniDB_TraktV2 xref in xrefs)
{
Providers.Azure.AzureWebAPI.Send_CrossRefAniDBTrakt(xref, anime.MainTitle);
}
// now get the links back from the cache and approve them
results = JMMServer.Providers.Azure.AzureWebAPI.Admin_Get_CrossRefAniDBTrakt(animeID);
if (results != null)
{
List<JMMServer.Providers.Azure.CrossRef_AniDB_Trakt> linksToApprove = new List<Providers.Azure.CrossRef_AniDB_Trakt>();
foreach (JMMServer.Providers.Azure.CrossRef_AniDB_Trakt xref in results)
{
if (xref.Username.Equals(ServerSettings.AniDB_Username, StringComparison.InvariantCultureIgnoreCase))
linksToApprove.Add(xref);
}
foreach (JMMServer.Providers.Azure.CrossRef_AniDB_Trakt xref in linksToApprove)
{
JMMServer.Providers.Azure.AzureWebAPI.Admin_Approve_CrossRefAniDBTrakt(xref.CrossRef_AniDB_TraktId.Value);
}
return "Success";
}
else
return "Failure to send links to web cache";
//return JMMServer.Providers.Azure.AzureWebAPI.Admin_Approve_CrossRefAniDBTrakt(crossRef_AniDB_TraktId);
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
}