public override void ProcessCommand()
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries ser = repSeries.GetByAnimeID(AnimeID);
if (ser!=null)
ser.UpdateStats(true, true, true);
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_MALUpdatedWatchedStatus: {0}", AnimeID);
try
{
// find the latest eps to update
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(AnimeID);
if (anime == null) return;
List<CrossRef_AniDB_MAL> crossRefs = anime.GetCrossRefMAL();
if (crossRefs == null || crossRefs.Count == 0)
return;
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries ser = repSeries.GetByAnimeID(AnimeID);
if (ser == null) return;
MALHelper.UpdateMALSeries(ser);
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_MALUpdatedWatchedStatus: {0} - {1}", AnimeID, ex.ToString());
return;
}
}
public static void InitCache()
{
string t = "AnimeSeries";
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t, string.Empty);
AnimeSeriesRepository repo = new AnimeSeriesRepository();
Cache = new PocoCache <int, AnimeSeries>(repo.InternalGetAll(), a => a.AnimeSeriesID);
Changes.AddOrUpdateRange(Cache.Keys);
AniDBIds = Cache.CreateIndex(a => a.AniDB_ID);
Groups = Cache.CreateIndex(a => a.AnimeGroupID);
int cnt = 0;
List <AnimeSeries> sers =
Cache.Values.Where(
a => a.ContractVersion < AnimeSeries.CONTRACT_VERSION || a.Contract?.AniDBAnime?.AniDBAnime == null)
.ToList();
int max = sers.Count;
foreach (AnimeSeries s in sers)
{
repo.Save(s, false, false, true);
cnt++;
if (cnt % 10 == 0)
{
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t,
" DbRegen - " + cnt + "/" + max);
}
}
ServerState.Instance.CurrentSetupStatus = string.Format(JMMServer.Properties.Resources.Database_Cache, t,
" DbRegen - " + max + "/" + max);
}
private List<string> GetPosterFilenames(ISession session)
{
List<string> allPosters = new List<string>();
// check if user has specied a fanart to always be used
if (DefaultAnimeSeriesID.HasValue)
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries defaultSeries = repSeries.GetByID(session, DefaultAnimeSeriesID.Value);
if (defaultSeries != null)
{
AniDB_Anime anime = defaultSeries.GetAnime(session);
string defPosterPathNoBlanks = anime.GetDefaultPosterPathNoBlanks(session);
if (!string.IsNullOrEmpty(defPosterPathNoBlanks) && File.Exists(defPosterPathNoBlanks))
{
allPosters.Add(defPosterPathNoBlanks);
return allPosters;
}
}
}
foreach (AnimeSeries ser in GetAllSeries(session))
{
AniDB_Anime anime = ser.GetAnime(session);
string defPosterPathNoBlanks = anime.GetDefaultPosterPathNoBlanks(session);
if (!string.IsNullOrEmpty(defPosterPathNoBlanks) && File.Exists(defPosterPathNoBlanks))
allPosters.Add(defPosterPathNoBlanks);
}
return allPosters;
}
private void UpdatePlexKodiContracts(AnimeSeries_User ugrp)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
AnimeSeriesRepository repo = new AnimeSeriesRepository();
AnimeSeries ser = repo.GetByID(ugrp.AnimeSeriesID);
Contract_AnimeSeries con = ser?.GetUserContract(ugrp.JMMUserID);
if (con == null)
{
return;
}
ugrp.PlexContract = Helper.GenerateFromSeries(con, ser, ser.GetAnime(session), ugrp.JMMUserID);
}
}
public override void ProcessCommand()
{
logger.Info("Get AniDB episode info: {0}", EpisodeID);
try
{
// we don't use this command to update episode info
// we actually use it to update the cross ref info instead
// and we only use it for the "Other Episodes" section of the FILE command
// because that field doesn't tell you what anime it belongs to
CrossRef_File_EpisodeRepository repCrossRefs = new CrossRef_File_EpisodeRepository();
List<CrossRef_File_Episode> xrefs = repCrossRefs.GetByEpisodeID(EpisodeID);
if (xrefs.Count == 0) return;
Raw_AniDB_Episode epInfo = JMMService.AnidbProcessor.GetEpisodeInfo(EpisodeID);
if (epInfo != null)
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
foreach (CrossRef_File_Episode xref in xrefs)
{
int oldAnimeID = xref.AnimeID;
xref.AnimeID = epInfo.AnimeID;
repCrossRefs.Save(xref);
AnimeSeries ser = repSeries.GetByAnimeID(oldAnimeID);
if (ser != null)
ser.UpdateStats(true, true, true);
StatsCache.Instance.UpdateUsingAnime(oldAnimeID);
ser = repSeries.GetByAnimeID(epInfo.AnimeID);
if (ser != null)
ser.UpdateStats(true, true, true);
StatsCache.Instance.UpdateUsingAnime(epInfo.AnimeID);
}
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_GetEpisode: {0} - {1}", EpisodeID, ex.ToString());
return;
}
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_TraktSyncCollectionSeries");
try
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries series = repSeries.GetByID(AnimeSeriesID);
if (series == null)
{
logger.Error("Could not find anime series: {0}", AnimeSeriesID);
return;
}
TraktTVHelper.SyncCollectionToTrakt_Series(series);
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_TraktSyncCollectionSeries: {0}", ex.ToString());
return;
}
}
public Contract_AnimeSeries_SaveResponse SaveSeries(Contract_AnimeSeries_Save contract, int userID)
{
Contract_AnimeSeries_SaveResponse contractout = new Contract_AnimeSeries_SaveResponse();
contractout.ErrorMessage = "";
contractout.AnimeSeries = null;
try
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries ser = null;
int? oldGroupID = null;
if (contract.AnimeSeriesID.HasValue)
{
ser = repSeries.GetByID(contract.AnimeSeriesID.Value);
if (ser == null)
{
contractout.ErrorMessage = "Could not find existing series with ID: " + contract.AnimeSeriesID.Value.ToString();
return contractout;
}
// check if we are moving a series
oldGroupID = ser.AnimeGroupID;
}
else
{
ser = new AnimeSeries();
ser.DateTimeCreated = DateTime.Now;
ser.DefaultAudioLanguage = "";
ser.DefaultSubtitleLanguage = "";
ser.MissingEpisodeCount = 0;
ser.MissingEpisodeCountGroups = 0;
ser.LatestLocalEpisodeNumber = 0;
ser.SeriesNameOverride = "";
}
ser.AnimeGroupID = contract.AnimeGroupID;
ser.AniDB_ID = contract.AniDB_ID;
ser.DefaultAudioLanguage = contract.DefaultAudioLanguage;
ser.DefaultSubtitleLanguage = contract.DefaultSubtitleLanguage;
ser.DateTimeUpdated = DateTime.Now;
ser.SeriesNameOverride = contract.SeriesNameOverride;
ser.DefaultFolder = contract.DefaultFolder;
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(ser.AniDB_ID);
if (anime == null)
{
contractout.ErrorMessage = string.Format("Could not find anime record with ID: {0}", ser.AniDB_ID);
return contractout;
}
repSeries.Save(ser);
// update stats for groups
//ser.TopLevelAnimeGroup.UpdateStatsFromTopLevel(true ,true, true);
ser.QueueUpdateStats();
if (oldGroupID.HasValue)
{
AnimeGroupRepository repGroups = new AnimeGroupRepository();
AnimeGroup grp = repGroups.GetByID(oldGroupID.Value);
if (grp != null)
{
grp.TopLevelAnimeGroup.UpdateStatsFromTopLevel(true, true, true);
}
}
List<CrossRef_AniDB_TvDBV2> xrefs = ser.GetCrossRefTvDBV2();
List<CrossRef_AniDB_MAL> xrefMAL = ser.CrossRefMAL;
List<TvDB_Series> sers = new List<TvDB_Series>();
foreach (CrossRef_AniDB_TvDBV2 xref in xrefs)
sers.Add(xref.GetTvDBSeries());
CrossRef_AniDB_Other xrefMovie = ser.CrossRefMovieDB;
MovieDB_Movie movie = null;
if (xrefMovie != null)
movie = xrefMovie.GetMovieDB_Movie();
contractout.AnimeSeries = ser.ToContract(anime, xrefs, ser.CrossRefMovieDB, ser.GetUserRecord(userID),
sers, xrefMAL, false, null, null, null, null,movie);
return contractout;
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
contractout.ErrorMessage = ex.Message;
return contractout;
}
}
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);
}
}
/// <summary>
/// Used to get a list of TvDB Series ID's that require updating
/// </summary>
/// <param name="tvDBIDs">The list Of Series ID's that need to be updated. Pass in an empty list</param>
/// <returns>The current server time before the update started</returns>
public string IncrementalTvDBUpdate(ref List<int> tvDBIDs, ref bool tvDBOnline)
{
// check if we have record of doing an automated update for the TvDB previously
// if we have then we have kept a record of the server time and can do a delta update
// otherwise we need to do a full update and keep a record of the time
List<int> allTvDBIDs = new List<int>();
tvDBIDs = new List<int>();
tvDBOnline = true;
try
{
CrossRef_AniDB_TvDBRepository repCrossRef = new CrossRef_AniDB_TvDBRepository();
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
// record the tvdb server time when we started
// we record the time now instead of after we finish, to include any possible misses
string currentTvDBServerTime = CurrentServerTime;
if (currentTvDBServerTime.Length == 0)
{
tvDBOnline = false;
return currentTvDBServerTime;
}
foreach (AnimeSeries ser in repSeries.GetAll())
{
List<CrossRef_AniDB_TvDBV2> xrefs = ser.GetCrossRefTvDBV2();
if (xrefs == null) continue;
foreach (CrossRef_AniDB_TvDBV2 xref in xrefs)
{
if (!allTvDBIDs.Contains(xref.TvDBID)) allTvDBIDs.Add(xref.TvDBID);
}
}
// get the time we last did a TvDB update
// if this is the first time it will be null
// update the anidb info ever 24 hours
ScheduledUpdateRepository repSched = new ScheduledUpdateRepository();
ScheduledUpdate sched = repSched.GetByUpdateType((int)ScheduledUpdateType.TvDBInfo);
string lastServerTime = "";
if (sched != null)
{
TimeSpan ts = DateTime.Now - sched.LastUpdate;
logger.Trace("Last tvdb info update was {0} hours ago", ts.TotalHours.ToString());
if (!string.IsNullOrEmpty(sched.UpdateDetails))
lastServerTime = sched.UpdateDetails;
// the UpdateDetails field for this type will actually contain the last server time from
// TheTvDB that a full update was performed
}
// get a list of updates from TvDB since that time
if (lastServerTime.Length > 0)
{
List<int> seriesList = GetUpdatedSeriesList(lastServerTime);
logger.Trace("{0} series have been updated since last download", seriesList.Count.ToString());
logger.Trace("{0} TvDB series locally", allTvDBIDs.Count.ToString());
foreach (int id in seriesList)
{
if (allTvDBIDs.Contains(id)) tvDBIDs.Add(id);
}
logger.Trace("{0} TvDB local series have been updated since last download", tvDBIDs.Count.ToString());
}
else
{
// use the full list
tvDBIDs = allTvDBIDs;
}
return currentTvDBServerTime;
}
catch (Exception ex)
{
logger.ErrorException("IncrementalTvDBUpdate: "+ ex.ToString(), ex);
return "";
}
}
public string SyncTraktSeries(int animeID)
{
try
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries ser = repSeries.GetByAnimeID(animeID);
if (ser == null) return "Could not find Anime Series";
CommandRequest_TraktSyncCollectionSeries cmd = new CommandRequest_TraktSyncCollectionSeries(ser.AnimeSeriesID, ser.GetSeriesName());
cmd.Save();
return string.Empty;
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
}
public Contract_AnimeSeries_SaveResponse MoveSeries(int animeSeriesID, int newAnimeGroupID, int userID)
{
Contract_AnimeSeries_SaveResponse contractout = new Contract_AnimeSeries_SaveResponse();
contractout.ErrorMessage = "";
contractout.AnimeSeries = null;
try
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries ser = null;
ser = repSeries.GetByID(animeSeriesID);
if (ser == null)
{
contractout.ErrorMessage = "Could not find existing series with ID: " + animeSeriesID.ToString();
return contractout;
}
// make sure the group exists
AnimeGroupRepository repGroups = new AnimeGroupRepository();
AnimeGroup grpTemp = repGroups.GetByID(newAnimeGroupID);
if (grpTemp == null)
{
contractout.ErrorMessage = "Could not find existing group with ID: " + newAnimeGroupID.ToString();
return contractout;
}
int oldGroupID = ser.AnimeGroupID;
ser.AnimeGroupID = newAnimeGroupID;
ser.DateTimeUpdated = DateTime.Now;
repSeries.Save(ser);
// update stats for new groups
//ser.TopLevelAnimeGroup.UpdateStatsFromTopLevel(true, true, true);
ser.QueueUpdateStats();
// update stats for old groups
AnimeGroup grp = repGroups.GetByID(oldGroupID);
if (grp != null)
{
grp.TopLevelAnimeGroup.UpdateStatsFromTopLevel(true, true, true);
}
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(ser.AniDB_ID);
if (anime == null)
{
contractout.ErrorMessage = string.Format("Could not find anime record with ID: {0}", ser.AniDB_ID);
return contractout;
}
List<CrossRef_AniDB_TvDBV2> xrefs = ser.GetCrossRefTvDBV2();
List<CrossRef_AniDB_MAL> xrefMAL = ser.CrossRefMAL;
List<TvDB_Series> sers = new List<TvDB_Series>();
foreach (CrossRef_AniDB_TvDBV2 xref in xrefs)
sers.Add(xref.GetTvDBSeries());
CrossRef_AniDB_Other xrefMovie = ser.CrossRefMovieDB;
MovieDB_Movie movie=null;
if (xrefMovie != null)
movie = xrefMovie.GetMovieDB_Movie();
contractout.AnimeSeries = ser.ToContract(anime, xrefs, xrefMovie,
ser.GetUserRecord(userID), sers, xrefMAL, false, null, null, null, null,movie);
return contractout;
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
contractout.ErrorMessage = ex.Message;
return contractout;
}
}
/// <summary>
/// Delete a series, and everything underneath it (episodes, files)
/// </summary>
/// <param name="animeSeriesID"></param>
/// <param name="deleteFiles">also delete the physical files</param>
/// <returns></returns>
public string DeleteAnimeSeries(int animeSeriesID, bool deleteFiles, bool deleteParentGroup)
{
try
{
AnimeEpisodeRepository repEps = new AnimeEpisodeRepository();
AnimeSeriesRepository repAnimeSer = new AnimeSeriesRepository();
VideoLocalRepository repVids = new VideoLocalRepository();
AnimeGroupRepository repGroups = new AnimeGroupRepository();
AnimeSeries ser = repAnimeSer.GetByID(animeSeriesID);
if (ser == null) return "Series does not exist";
int animeGroupID = ser.AnimeGroupID;
foreach (AnimeEpisode ep in ser.GetAnimeEpisodes())
{
foreach (VideoLocal vid in ep.GetVideoLocals())
{
if (deleteFiles)
{
logger.Info("Deleting video local record and file: {0}", vid.FullServerPath);
if (!File.Exists(vid.FullServerPath)) return "File could not be found";
File.Delete(vid.FullServerPath);
}
CommandRequest_DeleteFileFromMyList cmdDel = new CommandRequest_DeleteFileFromMyList(vid.Hash, vid.FileSize);
cmdDel.Save();
repVids.Delete(vid.VideoLocalID);
}
repEps.Delete(ep.AnimeEpisodeID);
}
repAnimeSer.Delete(ser.AnimeSeriesID);
// finally update stats
AnimeGroup grp = repGroups.GetByID(animeGroupID);
if (grp != null)
{
if (grp.GetAllSeries().Count == 0)
{
DeleteAnimeGroup(grp.AnimeGroupID, false);
}
else
{
grp.TopLevelAnimeGroup.UpdateStatsFromTopLevel(true, true, true);
StatsCache.Instance.UpdateUsingGroup(grp.TopLevelAnimeGroup.AnimeGroupID);
}
}
return "";
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
}
public Contract_AnimeGroup GetTopLevelGroupForSeries(int animeSeriesID, int userID)
{
try
{
AnimeGroupRepository repGroups = new AnimeGroupRepository();
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries ser = repSeries.GetByID(animeSeriesID);
if (ser == null) return null;
AnimeGroup grp = ser.TopLevelAnimeGroup;
if (grp == null) return null;
return grp.ToContract(grp.GetUserRecord(userID));
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return null;
}
public List<Contract_AniDB_Anime_Similar> GetSimilarAnimeLinks(int animeID, int userID)
{
List<Contract_AniDB_Anime_Similar> links = new List<Contract_AniDB_Anime_Similar>();
try
{
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(animeID);
if (anime == null) return links;
JMMUserRepository repUsers = new JMMUserRepository();
JMMUser juser = repUsers.GetByID(userID);
if (juser == null) return links;
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
foreach (AniDB_Anime_Similar link in anime.GetSimilarAnime())
{
AniDB_Anime animeLink = repAnime.GetByAnimeID(link.SimilarAnimeID);
if (animeLink != null)
{
if (!juser.AllowedAnime(animeLink)) continue;
}
// check if this anime has a series
AnimeSeries ser = repSeries.GetByAnimeID(link.SimilarAnimeID);
links.Add(link.ToContract(animeLink, ser, userID));
}
return links;
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return links;
}
}
public List<Contract_AnimeSeries> GetSeriesWithoutAnyFiles(int userID)
{
List<Contract_AnimeSeries> contracts = new List<Contract_AnimeSeries>();
VideoLocalRepository repVids = new VideoLocalRepository();
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
try
{
foreach (AnimeSeries ser in repSeries.GetAll())
{
if (repVids.GetByAniDBAnimeID(ser.AniDB_ID).Count == 0)
{
contracts.Add(ser.ToContract(ser.GetUserRecord(userID)));
}
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return contracts;
}
public string DeleteAnimeGroup(int animeGroupID, bool deleteFiles)
{
try
{
AnimeSeriesRepository repAnimeSer = new AnimeSeriesRepository();
AnimeGroupRepository repGroups = new AnimeGroupRepository();
AnimeGroup grp = repGroups.GetByID(animeGroupID);
if (grp == null) return "Group does not exist";
int? parentGroupID = grp.AnimeGroupParentID;
foreach (AnimeSeries ser in grp.GetAllSeries())
{
DeleteAnimeSeries(ser.AnimeSeriesID, deleteFiles, false);
}
// delete all sub groups
foreach (AnimeGroup subGroup in grp.GetAllChildGroups())
{
DeleteAnimeGroup(subGroup.AnimeGroupID, deleteFiles);
}
GroupFilterConditionRepository repConditions = new GroupFilterConditionRepository();
// delete any group filter conditions which reference these groups
foreach (GroupFilterCondition gfc in repConditions.GetByConditionType(GroupFilterConditionType.AnimeGroup))
{
int thisGrpID = 0;
int.TryParse(gfc.ConditionParameter, out thisGrpID);
if (thisGrpID == animeGroupID)
repConditions.Delete(gfc.GroupFilterConditionID);
}
repGroups.Delete(grp.AnimeGroupID);
// finally update stats
if (parentGroupID.HasValue)
{
AnimeGroup grpParent = repGroups.GetByID(parentGroupID.Value);
if (grpParent != null)
{
grpParent.TopLevelAnimeGroup.UpdateStatsFromTopLevel(true, true, true);
StatsCache.Instance.UpdateUsingGroup(grpParent.TopLevelAnimeGroup.AnimeGroupID);
}
}
return "";
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
}
public string SaveUser(Contract_JMMUser user)
{
JMMUserRepository repUsers = new JMMUserRepository();
try
{
bool existingUser = false;
bool updateStats = false;
JMMUser jmmUser = null;
if (user.JMMUserID.HasValue)
{
jmmUser = repUsers.GetByID(user.JMMUserID.Value);
if (jmmUser == null) return "User not found";
existingUser = true;
}
else
{
jmmUser = new JMMUser();
updateStats = true;
}
if (existingUser && jmmUser.IsAniDBUser != user.IsAniDBUser)
updateStats = true;
jmmUser.HideCategories = user.HideCategories;
jmmUser.IsAniDBUser = user.IsAniDBUser;
jmmUser.IsTraktUser = user.IsTraktUser;
jmmUser.IsAdmin = user.IsAdmin;
jmmUser.Username = user.Username;
jmmUser.CanEditServerSettings = user.CanEditServerSettings;
jmmUser.PlexUsers = user.PlexUsers;
if (string.IsNullOrEmpty(user.Password))
jmmUser.Password = "";
// make sure that at least one user is an admin
if (jmmUser.IsAdmin == 0)
{
bool adminExists = false;
List<JMMUser> users = repUsers.GetAll();
foreach (JMMUser userOld in users)
{
if (userOld.IsAdmin == 1)
{
if (existingUser)
{
if (userOld.JMMUserID != jmmUser.JMMUserID) adminExists = true;
}
else
adminExists = true;
}
}
if (!adminExists) return "At least one user must be an administrator";
}
repUsers.Save(jmmUser);
// update stats
if (updateStats)
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
foreach (AnimeSeries ser in repSeries.GetAll())
ser.QueueUpdateStats();
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
return "";
}
public void SetDefaultSeriesForGroup(int animeGroupID, int animeSeriesID)
{
try
{
AnimeGroupRepository repGroups = new AnimeGroupRepository();
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeGroup grp = repGroups.GetByID(animeGroupID);
if (grp == null) return;
AnimeSeries ser = repSeries.GetByID(animeSeriesID);
if (ser == null) return;
grp.DefaultAnimeSeriesID = animeSeriesID;
repGroups.Save(grp);
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
}
public static void ScanForMatches()
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
List<AnimeSeries> allSeries = repSeries.GetAll();
CrossRef_AniDB_OtherRepository repCrossRef = new CrossRef_AniDB_OtherRepository();
foreach (AnimeSeries ser in allSeries)
{
AniDB_Anime anime = ser.GetAnime();
if (anime == null) continue;
if (anime.IsMovieDBLinkDisabled) continue;
// don't scan if it is associated on the TvDB
if (anime.GetCrossRefTvDBV2().Count > 0) continue;
// don't scan if it is associated on the MovieDB
if (anime.GetCrossRefMovieDB() != null) continue;
// don't scan if it is not a movie
if (!anime.SearchOnMovieDB)
continue;
logger.Trace("Found anime movie without MovieDB association: " + anime.MainTitle);
CommandRequest_MovieDBSearchAnime cmd = new CommandRequest_MovieDBSearchAnime(ser.AniDB_ID, false);
cmd.Save();
}
}
public List<Contract_AnimeSearch> OnlineAnimeTitleSearch(string titleQuery)
{
List<Contract_AnimeSearch> retTitles = new List<Contract_AnimeSearch>();
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
try
{
// check if it is a title search or an ID search
int aid = 0;
if (int.TryParse(titleQuery, out aid))
{
// user is direct entering the anime id
// try the local database first
// if not download the data from AniDB now
AniDB_Anime anime = anime = JMMService.AnidbProcessor.GetAnimeInfoHTTP(aid, false, ServerSettings.AniDB_DownloadRelatedAnime);
if (anime != null)
{
Contract_AnimeSearch res = new Contract_AnimeSearch();
res.AnimeID = anime.AnimeID;
res.MainTitle = anime.MainTitle;
res.Titles = anime.AllTitles;
// check for existing series and group details
AnimeSeries ser = repSeries.GetByAnimeID(anime.AnimeID);
if (ser != null)
{
res.SeriesExists = true;
res.AnimeSeriesID = ser.AnimeSeriesID;
res.AnimeSeriesName = anime.GetFormattedTitle();
}
else
{
res.SeriesExists = false;
}
retTitles.Add(res);
}
}
else
{
// title search so look at the web cache
List<JMMServer.Providers.Azure.AnimeIDTitle> titles = JMMServer.Providers.Azure.AzureWebAPI.Get_AnimeTitle(titleQuery);
using (var session = JMMService.SessionFactory.OpenSession())
{
foreach (JMMServer.Providers.Azure.AnimeIDTitle tit in titles)
{
Contract_AnimeSearch res = new Contract_AnimeSearch();
res.AnimeID = tit.AnimeID;
res.MainTitle = tit.MainTitle;
res.Titles = tit.Titles;
// check for existing series and group details
AnimeSeries ser = repSeries.GetByAnimeID(tit.AnimeID);
if (ser != null)
{
res.SeriesExists = true;
res.AnimeSeriesID = ser.AnimeSeriesID;
res.AnimeSeriesName = ser.GetAnime(session).GetFormattedTitle(session);
}
else
{
res.SeriesExists = false;
}
retTitles.Add(res);
}
}
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
return retTitles;
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_GetUpdated");
try
{
List<int> animeIDsToUpdate = new List<int>();
ScheduledUpdateRepository repSched = new ScheduledUpdateRepository();
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
// check the automated update table to see when the last time we ran this command
ScheduledUpdate sched = repSched.GetByUpdateType((int)ScheduledUpdateType.AniDBUpdates);
if (sched != null)
{
int freqHours = Utils.GetScheduledHours(ServerSettings.AniDB_Anime_UpdateFrequency);
// if we have run this in the last 12 hours and are not forcing it, then exit
TimeSpan tsLastRun = DateTime.Now - sched.LastUpdate;
if (tsLastRun.TotalHours < freqHours)
{
if (!ForceRefresh) return;
}
}
long webUpdateTime = 0;
long webUpdateTimeNew = 0;
if (sched == null)
{
// if this is the first time, lets ask for last 3 days
DateTime localTime = DateTime.Now.AddDays(-3);
DateTime utcTime = localTime.ToUniversalTime();
webUpdateTime = long.Parse(Utils.AniDBDate(utcTime));
webUpdateTimeNew = long.Parse(Utils.AniDBDate(DateTime.Now.ToUniversalTime()));
sched = new ScheduledUpdate();
sched.UpdateType = (int)ScheduledUpdateType.AniDBUpdates;
}
else
{
logger.Trace("Last anidb info update was : {0}", sched.UpdateDetails);
webUpdateTime = long.Parse(sched.UpdateDetails);
webUpdateTimeNew = long.Parse(Utils.AniDBDate(DateTime.Now.ToUniversalTime()));
DateTime timeNow = DateTime.Now.ToUniversalTime();
logger.Info(string.Format("{0} since last UPDATED command",
Utils.FormatSecondsToDisplayTime(int.Parse((webUpdateTimeNew - webUpdateTime).ToString()))));
}
// get a list of updates from AniDB
// startTime will contain the date/time from which the updates apply to
JMMService.AnidbProcessor.GetUpdated(ref animeIDsToUpdate, ref webUpdateTime);
// now save the update time from AniDB
// we will use this next time as a starting point when querying the web cache
sched.LastUpdate = DateTime.Now;
sched.UpdateDetails = webUpdateTimeNew.ToString();
repSched.Save(sched);
if (animeIDsToUpdate.Count == 0)
{
logger.Info("No anime to be updated");
return;
}
int countAnime = 0;
int countSeries = 0;
foreach (int animeID in animeIDsToUpdate)
{
// update the anime from HTTP
AniDB_Anime anime = repAnime.GetByAnimeID(animeID);
if (anime == null)
{
logger.Trace("No local record found for Anime ID: {0}, so skipping...", animeID);
continue;
}
logger.Info("Updating CommandRequest_GetUpdated: {0} ", animeID);
// but only if it hasn't been recently updated
TimeSpan ts = DateTime.Now - anime.DateTimeUpdated;
if (ts.TotalHours > 4)
{
CommandRequest_GetAnimeHTTP cmdAnime = new CommandRequest_GetAnimeHTTP(animeID, true, false);
cmdAnime.Save();
countAnime++;
}
// update the group status
// this will allow us to determine which anime has missing episodes
// so we wonly get by an amime where we also have an associated series
AnimeSeries ser = repSeries.GetByAnimeID(animeID);
if (ser != null)
{
CommandRequest_GetReleaseGroupStatus cmdStatus = new CommandRequest_GetReleaseGroupStatus(animeID, true);
cmdStatus.Save();
countSeries++;
}
}
logger.Info("Updating {0} anime records, and {1} group status records", countAnime, countSeries);
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_GetUpdated: {0}", ex.ToString());
return;
}
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_GetReleaseGroupStatus: {0}", AnimeID);
try
{
// only get group status if we have an associated series
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries series = repSeries.GetByAnimeID(AnimeID);
if (series == null) return;
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(AnimeID);
if (anime == null) return;
// don't get group status if the anime has already ended more than 50 days ago
bool skip = false;
if (!ForceRefresh)
{
if (anime.EndDate.HasValue)
{
if (anime.EndDate.Value < DateTime.Now)
{
TimeSpan ts = DateTime.Now - anime.EndDate.Value;
if (ts.TotalDays > 50)
{
// don't skip if we have never downloaded this info before
AniDB_GroupStatusRepository repGrpStatus = new AniDB_GroupStatusRepository();
List<AniDB_GroupStatus> grpStatuses = repGrpStatus.GetByAnimeID(AnimeID);
if (grpStatuses != null && grpStatuses.Count > 0)
{
skip = true;
}
}
}
}
}
if (skip)
{
logger.Info("Skipping group status command because anime has already ended: {0}", anime.ToString());
return;
}
GroupStatusCollection grpCol = JMMService.AnidbProcessor.GetReleaseGroupStatusUDP(AnimeID);
if (ServerSettings.AniDB_DownloadReleaseGroups)
{
// save in bulk to improve performance
using (var session = JMMService.SessionFactory.OpenSession())
{
using (var transaction = session.BeginTransaction())
{
foreach (Raw_AniDB_GroupStatus grpStatus in grpCol.Groups)
{
CommandRequest_GetReleaseGroup cmdRelgrp = new CommandRequest_GetReleaseGroup(grpStatus.GroupID, false);
session.SaveOrUpdate(cmdRelgrp);
}
transaction.Commit();
}
}
}
//}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_GetReleaseGroupStatus: {0} - {1}", AnimeID, ex.ToString());
return;
}
}
public void RecreateAllGroups()
{
try
{
// pause queues
JMMService.CmdProcessorGeneral.Paused = true;
JMMService.CmdProcessorHasher.Paused = true;
JMMService.CmdProcessorImages.Paused = true;
AnimeGroupRepository repGroups = new AnimeGroupRepository();
AnimeGroup_UserRepository repGroupUser = new AnimeGroup_UserRepository();
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
// get all the old groups
List<AnimeGroup> oldGroups = repGroups.GetAll();
List<AnimeGroup_User> oldGroupUsers = repGroupUser.GetAll();
// create a new group, where we will place all the series temporarily
AnimeGroup tempGroup = new AnimeGroup();
tempGroup.GroupName = "AAA Migrating Groups AAA";
tempGroup.Description = "AAA Migrating Groups AAA";
tempGroup.SortName = "AAA Migrating Groups AAA";
tempGroup.DateTimeUpdated = DateTime.Now;
tempGroup.DateTimeCreated = DateTime.Now;
repGroups.Save(tempGroup);
// move all series to the new group
foreach (AnimeSeries ser in repSeries.GetAll())
{
ser.AnimeGroupID = tempGroup.AnimeGroupID;
repSeries.Save(ser, false);
}
// delete all the old groups
foreach (AnimeGroup grp in oldGroups)
repGroups.Delete(grp.AnimeGroupID);
// delete all the old group user records
foreach (AnimeGroup_User grpUser in oldGroupUsers)
repGroupUser.Delete(grpUser.AnimeGroupID);
// recreate groups
foreach (AnimeSeries ser in repSeries.GetAll())
{
bool createNewGroup = true;
if (ServerSettings.AutoGroupSeries)
{
List<AnimeGroup> grps = AnimeGroup.GetRelatedGroupsFromAnimeID(ser.AniDB_ID);
// only use if there is just one result
if (grps != null && grps.Count > 0 && !grps[0].GroupName.Equals("AAA Migrating Groups AAA"))
{
ser.AnimeGroupID = grps[0].AnimeGroupID;
createNewGroup = false;
}
}
if (createNewGroup)
{
AnimeGroup anGroup = new AnimeGroup();
anGroup.Populate(ser);
repGroups.Save(anGroup);
ser.AnimeGroupID = anGroup.AnimeGroupID;
}
repSeries.Save(ser, false);
}
// delete the temp group
if (tempGroup.GetAllSeries().Count == 0)
repGroups.Delete(tempGroup.AnimeGroupID);
// create group user records and update group stats
foreach (AnimeGroup grp in repGroups.GetAll())
grp.UpdateStatsFromTopLevel(true, true);
// un-pause queues
JMMService.CmdProcessorGeneral.Paused = false;
JMMService.CmdProcessorHasher.Paused = false;
JMMService.CmdProcessorImages.Paused = false;
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
}
void workerMyAnime2_DoWork(object sender, DoWorkEventArgs e)
{
MA2Progress ma2Progress = new MA2Progress();
ma2Progress.CurrentFile = 0;
ma2Progress.ErrorMessage = "";
ma2Progress.MigratedFiles = 0;
ma2Progress.TotalFiles = 0;
try
{
string databasePath = e.Argument as string;
string connString = string.Format(@"data source={0};useutf16encoding=True", databasePath);
SQLiteConnection myConn = new SQLiteConnection(connString);
myConn.Open();
// get a list of unlinked files
VideoLocalRepository repVids = new VideoLocalRepository();
AniDB_EpisodeRepository repAniEps = new AniDB_EpisodeRepository();
AniDB_AnimeRepository repAniAnime = new AniDB_AnimeRepository();
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeEpisodeRepository repEps = new AnimeEpisodeRepository();
List<VideoLocal> vids = repVids.GetVideosWithoutEpisode();
ma2Progress.TotalFiles = vids.Count;
foreach (VideoLocal vid in vids)
{
ma2Progress.CurrentFile = ma2Progress.CurrentFile + 1;
workerMyAnime2.ReportProgress(0, ma2Progress);
// search for this file in the XrossRef table in MA2
string sql = string.Format("SELECT AniDB_EpisodeID from CrossRef_Episode_FileHash WHERE Hash = '{0}' AND FileSize = {1}", vid.ED2KHash, vid.FileSize);
SQLiteCommand sqCommand = new SQLiteCommand(sql);
sqCommand.Connection = myConn;
SQLiteDataReader myReader = sqCommand.ExecuteReader();
while (myReader.Read())
{
int episodeID = 0;
if (!int.TryParse(myReader.GetValue(0).ToString(), out episodeID)) continue;
if (episodeID <= 0) continue;
sql = string.Format("SELECT AnimeID from AniDB_Episode WHERE EpisodeID = {0}", episodeID);
sqCommand = new SQLiteCommand(sql);
sqCommand.Connection = myConn;
SQLiteDataReader myReader2 = sqCommand.ExecuteReader();
while (myReader2.Read())
{
int animeID = myReader2.GetInt32(0);
// so now we have all the needed details we can link the file to the episode
// as long as wehave the details in JMM
AniDB_Anime anime = null;
AniDB_Episode ep = repAniEps.GetByEpisodeID(episodeID);
if (ep == null)
{
logger.Debug("Getting Anime record from AniDB....");
anime = JMMService.AnidbProcessor.GetAnimeInfoHTTP(animeID, true, ServerSettings.AutoGroupSeries);
}
else
anime = repAniAnime.GetByAnimeID(animeID);
// create the group/series/episode records if needed
AnimeSeries ser = null;
if (anime == null) continue;
logger.Debug("Creating groups, series and episodes....");
// check if there is an AnimeSeries Record associated with this AnimeID
ser = repSeries.GetByAnimeID(animeID);
if (ser == null)
{
// create a new AnimeSeries record
ser = anime.CreateAnimeSeriesAndGroup();
}
ser.CreateAnimeEpisodes();
// check if we have any group status data for this associated anime
// if not we will download it now
AniDB_GroupStatusRepository repStatus = new AniDB_GroupStatusRepository();
if (repStatus.GetByAnimeID(anime.AnimeID).Count == 0)
{
CommandRequest_GetReleaseGroupStatus cmdStatus = new CommandRequest_GetReleaseGroupStatus(anime.AnimeID, false);
cmdStatus.Save();
}
// update stats
ser.EpisodeAddedDate = DateTime.Now;
repSeries.Save(ser);
AnimeGroupRepository repGroups = new AnimeGroupRepository();
foreach (AnimeGroup grp in ser.AllGroupsAbove)
{
grp.EpisodeAddedDate = DateTime.Now;
repGroups.Save(grp);
}
AnimeEpisode epAnime = repEps.GetByAniDBEpisodeID(episodeID);
if (epAnime == null)
continue;
CrossRef_File_EpisodeRepository repXRefs = new CrossRef_File_EpisodeRepository();
CrossRef_File_Episode xref = new CrossRef_File_Episode();
try
{
xref.PopulateManually(vid, epAnime);
}
catch (Exception ex)
{
string msg = string.Format("Error populating XREF: {0} - {1}", vid.ToStringDetailed(), ex.ToString());
throw;
}
repXRefs.Save(xref);
vid.RenameIfRequired();
vid.MoveFileIfRequired();
// update stats for groups and series
if (ser != null)
{
// update all the groups above this series in the heirarchy
ser.UpdateStats(true, true, true);
StatsCache.Instance.UpdateUsingSeries(ser.AnimeSeriesID);
}
// Add this file to the users list
if (ServerSettings.AniDB_MyList_AddFiles)
{
CommandRequest_AddFileToMyList cmd = new CommandRequest_AddFileToMyList(vid.ED2KHash);
cmd.Save();
}
ma2Progress.MigratedFiles = ma2Progress.MigratedFiles + 1;
workerMyAnime2.ReportProgress(0, ma2Progress);
}
myReader2.Close();
//Console.WriteLine(myReader.GetString(0));
}
myReader.Close();
}
myConn.Close();
ma2Progress.CurrentFile = ma2Progress.CurrentFile + 1;
workerMyAnime2.ReportProgress(0, ma2Progress);
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
ma2Progress.ErrorMessage = ex.Message;
workerMyAnime2.ReportProgress(0, ma2Progress);
}
}
public string RemoveAssociationOnFile(int videoLocalID, int aniDBEpisodeID)
{
try
{
VideoLocalRepository repVids = new VideoLocalRepository();
CrossRef_File_EpisodeRepository repXRefs = new CrossRef_File_EpisodeRepository();
VideoLocal vid = repVids.GetByID(videoLocalID);
if (vid == null)
return "Could not find video record";
int? animeSeriesID = null;
foreach (AnimeEpisode ep in vid.GetAnimeEpisodes())
{
if (ep.AniDB_EpisodeID != aniDBEpisodeID) continue;
animeSeriesID = ep.AnimeSeriesID;
CrossRef_File_Episode xref = repXRefs.GetByHashAndEpisodeID(vid.Hash, ep.AniDB_EpisodeID);
if (xref != null)
{
if (xref.CrossRefSource == (int)CrossRefSource.AniDB)
return "Cannot remove associations created from AniDB data";
// delete cross ref from web cache
CommandRequest_WebCacheDeleteXRefFileEpisode cr = new CommandRequest_WebCacheDeleteXRefFileEpisode(vid.Hash, ep.AniDB_EpisodeID);
cr.Save();
repXRefs.Delete(xref.CrossRef_File_EpisodeID);
}
}
if (animeSeriesID.HasValue)
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries ser = repSeries.GetByID(animeSeriesID.Value);
if (ser != null)
ser.QueueUpdateStats();
}
return "";
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
}
public static void ScanForMatches()
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
List<AnimeSeries> allSeries = repSeries.GetAll();
CrossRef_AniDB_TvDBV2Repository repCrossRef = new CrossRef_AniDB_TvDBV2Repository();
List<CrossRef_AniDB_TvDBV2> allCrossRefs = repCrossRef.GetAll();
List<int> alreadyLinked = new List<int>();
foreach (CrossRef_AniDB_TvDBV2 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 tvDB association: " + anime.MainTitle);
if (!anime.SearchOnTvDB) continue;
if (anime.IsTvDBLinkDisabled)
{
logger.Trace("Skipping scan tvDB link because it is disabled: " + anime.MainTitle);
continue;
}
}
CommandRequest_TvDBSearchAnime cmd = new CommandRequest_TvDBSearchAnime(ser.AniDB_ID, false);
cmd.Save();
}
}
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;
}
}
private void ProcessFile_AniDB(VideoLocal vidLocal)
{
logger.Trace("Checking for AniDB_File record for: {0} --- {1}", vidLocal.Hash, vidLocal.FilePath);
// check if we already have this AniDB_File info in the database
AniDB_FileRepository repAniFile = new AniDB_FileRepository();
AniDB_EpisodeRepository repAniEps = new AniDB_EpisodeRepository();
AniDB_AnimeRepository repAniAnime = new AniDB_AnimeRepository();
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
VideoLocalRepository repVidLocals = new VideoLocalRepository();
AnimeEpisodeRepository repEps = new AnimeEpisodeRepository();
CrossRef_File_EpisodeRepository repXrefFE = new CrossRef_File_EpisodeRepository();
AniDB_File aniFile = null;
if (!ForceAniDB)
{
aniFile = repAniFile.GetByHashAndFileSize(vidLocal.Hash, vlocal.FileSize);
if (aniFile == null)
logger.Trace("AniDB_File record not found");
}
int animeID = 0;
if (aniFile == null)
{
// get info from AniDB
logger.Debug("Getting AniDB_File record from AniDB....");
Raw_AniDB_File fileInfo = JMMService.AnidbProcessor.GetFileInfo(vidLocal);
if (fileInfo != null)
{
// check if we already have a record
aniFile = repAniFile.GetByHashAndFileSize(vidLocal.Hash, vlocal.FileSize);
if (aniFile == null)
aniFile = new AniDB_File();
aniFile.Populate(fileInfo);
//overwrite with local file name
string localFileName = Path.GetFileName(vidLocal.FilePath);
aniFile.FileName = localFileName;
repAniFile.Save(aniFile, false);
aniFile.CreateLanguages();
aniFile.CreateCrossEpisodes(localFileName);
if (!string.IsNullOrEmpty(fileInfo.OtherEpisodesRAW))
{
string[] epIDs = fileInfo.OtherEpisodesRAW.Split(',');
foreach (string epid in epIDs)
{
int id = 0;
if (int.TryParse(epid, out id))
{
CommandRequest_GetEpisode cmdEp = new CommandRequest_GetEpisode(id);
cmdEp.Save();
}
}
}
animeID = aniFile.AnimeID;
}
}
bool missingEpisodes = false;
// if we still haven't got the AniDB_File Info we try the web cache or local records
if (aniFile == null)
{
// check if we have any records from previous imports
List<CrossRef_File_Episode> crossRefs = repXrefFE.GetByHash(vidLocal.Hash);
if (crossRefs == null || crossRefs.Count == 0)
{
// lets see if we can find the episode/anime info from the web cache
if (ServerSettings.WebCache_XRefFileEpisode_Get)
{
crossRefs = XMLService.Get_CrossRef_File_Episode(vidLocal);
if (crossRefs == null || crossRefs.Count == 0)
{
logger.Debug("Cannot find AniDB_File record or get cross ref from web cache record so exiting: {0}", vidLocal.ED2KHash);
return;
}
else
{
foreach (CrossRef_File_Episode xref in crossRefs)
{
// in this case we need to save the cross refs manually as AniDB did not provide them
repXrefFE.Save(xref);
}
}
}
else
{
logger.Debug("Cannot get AniDB_File record so exiting: {0}", vidLocal.ED2KHash);
return;
}
}
// we assume that all episodes belong to the same anime
foreach (CrossRef_File_Episode xref in crossRefs)
{
animeID = xref.AnimeID;
AniDB_Episode ep = repAniEps.GetByEpisodeID(xref.EpisodeID);
if (ep == null) missingEpisodes = true;
}
}
else
{
// check if we have the episode info
// if we don't, we will need to re-download the anime info (which also has episode info)
if (aniFile.EpisodeCrossRefs.Count == 0)
{
animeID = aniFile.AnimeID;
// if we have the anidb file, but no cross refs it means something has been broken
logger.Debug("Could not find any cross ref records for: {0}", vidLocal.ED2KHash);
missingEpisodes = true;
}
else
{
foreach (CrossRef_File_Episode xref in aniFile.EpisodeCrossRefs)
{
AniDB_Episode ep = repAniEps.GetByEpisodeID(xref.EpisodeID);
if (ep == null)
missingEpisodes = true;
animeID = xref.AnimeID;
}
}
}
// get from DB
AniDB_Anime anime = repAniAnime.GetByAnimeID(animeID);
bool animeRecentlyUpdated = false;
if (anime != null)
{
TimeSpan ts = DateTime.Now - anime.DateTimeUpdated;
if (ts.TotalHours < 4) animeRecentlyUpdated = true;
}
// even if we are missing episode info, don't get data more than once every 4 hours
// this is to prevent banning
if (missingEpisodes && !animeRecentlyUpdated)
{
logger.Debug("Getting Anime record from AniDB....");
// try using the cache first
using (var session = JMMService.SessionFactory.OpenSession())
{
anime = JMMService.AnidbProcessor.GetAnimeInfoHTTPFromCache(session, animeID, ServerSettings.AutoGroupSeries);
}
// if not in cache try from AniDB
if (anime == null)
anime = JMMService.AnidbProcessor.GetAnimeInfoHTTP(animeID, true, ServerSettings.AutoGroupSeries);
}
// create the group/series/episode records if needed
AnimeSeries ser = null;
if (anime != null)
{
logger.Debug("Creating groups, series and episodes....");
// check if there is an AnimeSeries Record associated with this AnimeID
ser = repSeries.GetByAnimeID(animeID);
if (ser == null)
{
// create a new AnimeSeries record
ser = anime.CreateAnimeSeriesAndGroup();
}
ser.CreateAnimeEpisodes();
// check if we have any group status data for this associated anime
// if not we will download it now
AniDB_GroupStatusRepository repStatus = new AniDB_GroupStatusRepository();
if (repStatus.GetByAnimeID(anime.AnimeID).Count == 0)
{
CommandRequest_GetReleaseGroupStatus cmdStatus = new CommandRequest_GetReleaseGroupStatus(anime.AnimeID, false);
cmdStatus.Save();
}
// update stats
ser.EpisodeAddedDate = DateTime.Now;
repSeries.Save(ser);
AnimeGroupRepository repGroups = new AnimeGroupRepository();
foreach (AnimeGroup grp in ser.AllGroupsAbove)
{
grp.EpisodeAddedDate = DateTime.Now;
repGroups.Save(grp);
}
}
vidLocal.RenameIfRequired();
vidLocal.MoveFileIfRequired();
// update stats for groups and series
if (ser != null)
{
// update all the groups above this series in the heirarchy
ser.UpdateStats(true, true, true);
StatsCache.Instance.UpdateUsingSeries(ser.AnimeSeriesID);
}
// Add this file to the users list
if (ServerSettings.AniDB_MyList_AddFiles)
{
CommandRequest_AddFileToMyList cmd = new CommandRequest_AddFileToMyList(vidLocal.ED2KHash);
cmd.Save();
}
// lets also try adding to the users trakt collecion by sync'ing the series
if (ser != null)
{
CommandRequest_TraktSyncCollectionSeries cmdTrakt = new CommandRequest_TraktSyncCollectionSeries(ser.AnimeSeriesID, ser.GetAnime().MainTitle);
cmdTrakt.Save();
}
// sync the series on MAL
if (ser != null)
{
CommandRequest_MALUpdatedWatchedStatus cmdMAL = new CommandRequest_MALUpdatedWatchedStatus(ser.AniDB_ID);
cmdMAL.Save();
}
}
public string RemoveLinkAniDBTvDB(int animeID, int aniEpType, int aniEpNumber, int tvDBID, int tvSeasonNumber, int tvEpNumber)
{
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.TvDB_Banner ||
image.ImageParentType == (int)JMMImageType.TvDB_Cover ||
image.ImageParentType == (int)JMMImageType.TvDB_FanArt)
{
if (image.ImageParentID == tvDBID)
repDefaults.Delete(image.AniDB_Anime_DefaultImageID);
}
}
TvDBHelper.RemoveLinkAniDBTvDB(animeID, (enEpisodeType)aniEpType, aniEpNumber, tvDBID, tvSeasonNumber, tvEpNumber);
return "";
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
}
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>
/// Removes all tvdb links for one anime
/// </summary>
/// <param name="animeID"></param>
/// <returns></returns>
public string RemoveLinkAniDBTvDBForAnime(int animeID)
{
try
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries ser = repSeries.GetByAnimeID(animeID);
if (ser == null) return "Could not find Series for Anime!";
CrossRef_AniDB_TvDBV2Repository repCrossRef= new CrossRef_AniDB_TvDBV2Repository();
List<CrossRef_AniDB_TvDBV2> xrefs = repCrossRef.GetByAnimeID(animeID);
if (xrefs == null) return "";
AniDB_Anime_DefaultImageRepository repDefaults = new AniDB_Anime_DefaultImageRepository();
foreach (CrossRef_AniDB_TvDBV2 xref in xrefs)
{
// check if there are default images used associated
List<AniDB_Anime_DefaultImage> images = repDefaults.GetByAnimeID(animeID);
foreach (AniDB_Anime_DefaultImage image in images)
{
if (image.ImageParentType == (int)JMMImageType.TvDB_Banner ||
image.ImageParentType == (int)JMMImageType.TvDB_Cover ||
image.ImageParentType == (int)JMMImageType.TvDB_FanArt)
{
if (image.ImageParentID == xref.TvDBID)
repDefaults.Delete(image.AniDB_Anime_DefaultImageID);
}
}
TvDBHelper.RemoveLinkAniDBTvDB(xref.AnimeID, (enEpisodeType)xref.AniDBStartEpisodeType, xref.AniDBStartEpisodeNumber,
xref.TvDBID, xref.TvDBSeasonNumber, xref.TvDBStartEpisodeNumber);
}
return "";
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
}
