public override void ProcessCommand()
{
try
{
//if (string.IsNullOrEmpty(ServerSettings.WebCacheAuthKey)) return;
CrossRef_AniDB_TvDBV2Repository repCrossRef = new CrossRef_AniDB_TvDBV2Repository();
CrossRef_AniDB_TvDBV2 xref = repCrossRef.GetByID(CrossRef_AniDB_TvDBID);
if (xref == null)
{
return;
}
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(xref.AnimeID);
if (anime == null)
{
return;
}
AzureWebAPI.Send_CrossRefAniDBTvDB(xref, anime.MainTitle);
}
catch (Exception ex)
{
logger.ErrorException("Error processing CommandRequest_WebCacheSendXRefAniDBTvDB: {0}" + ex.ToString(),
ex);
return;
}
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_MALUploadStatusToMAL");
try
{
if (string.IsNullOrEmpty(ServerSettings.MAL_Username) || string.IsNullOrEmpty(ServerSettings.MAL_Password))
{
return;
}
// find the latest eps to update
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
List <AniDB_Anime> animes = repAnime.GetAll();
foreach (AniDB_Anime anime in animes)
{
CommandRequest_MALUpdatedWatchedStatus cmd = new CommandRequest_MALUpdatedWatchedStatus(anime.AnimeID);
cmd.Save();
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_MALUploadStatusToMAL: {0}", ex.ToString());
return;
}
}
public AniDB_Anime GetAnime(ISession session)
{
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anidb_anime = repAnime.GetByAnimeID(session, this.AniDB_ID);
return(anidb_anime);
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_GetAnimeHTTP: {0}", AnimeID);
try
{
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = JMMService.AnidbProcessor.GetAnimeInfoHTTP(AnimeID, ForceRefresh, DownloadRelations);
// NOTE - related anime are downloaded when the relations are created
// download group status info for this anime
// the group status will also help us determine missing episodes for a series
// download reviews
if (ServerSettings.AniDB_DownloadReviews)
{
CommandRequest_GetReviews cmd = new CommandRequest_GetReviews(AnimeID, ForceRefresh);
cmd.Save();
}
// Request an image download
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_GetAnimeHTTP: {0} - {1}", AnimeID, ex.ToString());
return;
}
}
public static void UpdateAniDBTitles()
{
int freqHours = 100;
bool process = ServerSettings.AniDB_Username.Equals("jonbaby", StringComparison.InvariantCultureIgnoreCase) ||
ServerSettings.AniDB_Username.Equals("jmediamanager", StringComparison.InvariantCultureIgnoreCase);
if (!process) return;
// check for any updated anime info every 100 hours
ScheduledUpdateRepository repSched = new ScheduledUpdateRepository();
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
ScheduledUpdate sched = repSched.GetByUpdateType((int)ScheduledUpdateType.AniDBTitles);
if (sched != null)
{
// if we have run this in the last 100 hours and are not forcing it, then exit
TimeSpan tsLastRun = DateTime.Now - sched.LastUpdate;
if (tsLastRun.TotalHours < freqHours) return;
}
if (sched == null)
{
sched = new ScheduledUpdate();
sched.UpdateType = (int)ScheduledUpdateType.AniDBTitles;
sched.UpdateDetails = "";
}
sched.LastUpdate = DateTime.Now;
repSched.Save(sched);
CommandRequest_GetAniDBTitles cmd = new CommandRequest_GetAniDBTitles();
cmd.Save();
}
public static void CheckForMALUpdate(bool forceRefresh)
{
if (ServerSettings.AniDB_Anime_UpdateFrequency == ScheduledUpdateFrequency.Never && !forceRefresh) return;
int freqHours = Utils.GetScheduledHours(ServerSettings.MAL_UpdateFrequency);
// check for any updated anime info every 12 hours
ScheduledUpdateRepository repSched = new ScheduledUpdateRepository();
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
ScheduledUpdate sched = repSched.GetByUpdateType((int)ScheduledUpdateType.MALUpdate);
if (sched != null)
{
// 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;
}
}
RunImport_ScanMAL();
if (sched == null)
{
sched = new ScheduledUpdate();
sched.UpdateType = (int)ScheduledUpdateType.MALUpdate;
sched.UpdateDetails = "";
}
sched.LastUpdate = DateTime.Now;
repSched.Save(sched);
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_GetReviews: {0}", AnimeID);
try
{
return;
// we will always assume that an anime was downloaded via http first
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(AnimeID);
if (anime != null)
{
// reviews count will be 0 when the anime is only downloaded via HTTP
if (ForceRefresh || anime.AnimeReviews.Count == 0)
{
anime = JMMService.AnidbProcessor.GetAnimeInfoUDP(AnimeID, true);
}
foreach (AniDB_Anime_Review animeRev in anime.AnimeReviews)
{
JMMService.AnidbProcessor.GetReviewUDP(animeRev.ReviewID);
}
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_GetReviews: {0} - {1}", AnimeID, ex.ToString());
return;
}
}
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 override void ProcessCommand()
{
try
{
bool process = (ServerSettings.AniDB_Username.Equals("jonbaby", StringComparison.InvariantCultureIgnoreCase) ||
ServerSettings.AniDB_Username.Equals("jmediamanager", StringComparison.InvariantCultureIgnoreCase));
if (!process)
{
return;
}
AniDB_AnimeRepository rep = new AniDB_AnimeRepository();
AniDB_Anime anime = rep.GetByAnimeID(AnimeID);
if (anime == null)
{
return;
}
if (anime.AllCategories.ToUpper().Contains("18 RESTRICTED"))
{
return;
}
AzureWebAPI.Send_AnimeFull(anime);
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_Azure_SendAnimeFull: {0} - {1}", AnimeID, ex.ToString());
return;
}
}
public AniDB_Anime GetAnimeInfoHTTP(ISession session, int animeID, bool forceRefresh, bool downloadRelations)
{
//if (!Login()) return null;
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = null;
bool skip = true;
if (forceRefresh)
{
skip = false;
}
else
{
anime = repAnime.GetByAnimeID(session, animeID);
if (anime == null)
{
skip = false;
}
}
if (skip)
{
if (anime == null)
{
anime = repAnime.GetByAnimeID(session, animeID);
}
return(anime);
}
AniDBHTTPCommand_GetFullAnime getAnimeCmd = null;
lock (lockAniDBConnections)
{
Pause();
getAnimeCmd = new AniDBHTTPCommand_GetFullAnime();
getAnimeCmd.Init(animeID, false, forceRefresh, false);
getAnimeCmd.Process();
}
if (getAnimeCmd.Anime != null)
{
anime = SaveResultsForAnimeXML(session, animeID, downloadRelations, getAnimeCmd);
if (forceRefresh)
{
CommandRequest_Azure_SendAnimeFull cmdAzure = new CommandRequest_Azure_SendAnimeFull(anime.AnimeID);
cmdAzure.Save(session);
}
}
return(anime);
}
public static void RunImport_UpdateAllAniDB()
{
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
foreach (AniDB_Anime anime in repAnime.GetAll())
{
CommandRequest_GetAnimeHTTP cmd = new CommandRequest_GetAnimeHTTP(anime.AnimeID, true, false);
cmd.Save();
}
}
public override void ProcessCommand()
{
try
{
bool process =
ServerSettings.AniDB_Username.Equals("jonbaby", StringComparison.InvariantCultureIgnoreCase) ||
ServerSettings.AniDB_Username.Equals("jmediamanager", StringComparison.InvariantCultureIgnoreCase);
if (!process)
{
return;
}
AniDB_AnimeRepository rep = new AniDB_AnimeRepository();
AniDB_Anime anime = rep.GetByAnimeID(AnimeID);
if (anime == null)
{
return;
}
string appPath =
System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
string filePath = Path.Combine(appPath, "Anime_HTTP");
if (!Directory.Exists(filePath))
{
Directory.CreateDirectory(filePath);
}
string fileName = string.Format("AnimeDoc_{0}.xml", AnimeID);
string fileNameWithPath = Path.Combine(filePath, fileName);
string rawXML = "";
if (File.Exists(fileNameWithPath))
{
StreamReader re = File.OpenText(fileNameWithPath);
rawXML = re.ReadToEnd();
re.Close();
}
AnimeXML xml = new AnimeXML();
xml.AnimeID = AnimeID;
xml.AnimeName = anime.MainTitle;
xml.DateDownloaded = 0;
xml.Username = ServerSettings.AniDB_Username;
xml.XMLContent = rawXML;
AzureWebAPI.Send_AnimeXML(xml);
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_Azure_SendAnimeXML: {0} - {1}", AnimeID, ex.ToString());
return;
}
}
public Contract_DuplicateFile ToContract()
{
Contract_DuplicateFile contract = new Contract_DuplicateFile();
contract.DateTimeUpdated = this.DateTimeUpdated;
contract.DuplicateFileID = this.DuplicateFileID;
contract.FilePathFile1 = this.FilePathFile1;
contract.FilePathFile2 = this.FilePathFile2;
contract.Hash = this.Hash;
contract.ImportFolderIDFile1 = this.ImportFolderIDFile1;
contract.ImportFolderIDFile2 = this.ImportFolderIDFile2;
if (this.ImportFolder1 != null)
{
contract.ImportFolder1 = this.ImportFolder1.ToContract();
}
else
{
contract.ImportFolder1 = null;
}
if (this.ImportFolder2 != null)
{
contract.ImportFolder2 = this.ImportFolder2.ToContract();
}
else
{
contract.ImportFolder2 = null;
}
if (AniDBFile != null)
{
List <AniDB_Episode> eps = AniDBFile.Episodes;
if (eps.Count > 0)
{
contract.EpisodeNumber = eps[0].EpisodeNumber;
contract.EpisodeType = eps[0].EpisodeType;
contract.EpisodeName = eps[0].RomajiName;
contract.AnimeID = eps[0].AnimeID;
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(eps[0].AnimeID);
if (anime != null)
{
contract.AnimeName = anime.MainTitle;
}
}
}
return(contract);
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_GetCharactersCreators: {0}", AnimeID);
try
{
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Character_CreatorRepository repCharCreators = new AniDB_Character_CreatorRepository();
AniDB_Anime anime = null;
if (ForceRefresh)
{
// redownload anime details from http ap so we can get an update character list
anime = JMMService.AnidbProcessor.GetAnimeInfoHTTP(AnimeID, false, false);
}
else
{
anime = repAnime.GetByAnimeID(AnimeID);
}
if (anime == null)
{
return;
}
foreach (AniDB_Anime_Character animeChar in anime.AnimeCharacters)
{
//MainWindow.anidbProcessor.UpdateCharacterInfo(charref.CharID, false);
//logger.Trace("Downloading char info: {0}", animeChar.CharID);
CommandRequest_GetCharacter cmdChar = new CommandRequest_GetCharacter(animeChar.CharID, ForceRefresh);
cmdChar.Save();
// for each of the creators for this character
foreach (AniDB_Character_Seiyuu aac in repCharCreators.GetByCharID(animeChar.CharID))
{
CommandRequest_GetCreator cmdCreators = new CommandRequest_GetCreator(aac.SeiyuuID, ForceRefresh);
cmdCreators.Save();
}
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_GetCharactersCreators: {0} - {1}", AnimeID, ex.ToString());
return;
}
}
public static void FixDuplicateTvDBLinks()
{
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
// delete all TvDB link duplicates
CrossRef_AniDB_TvDBRepository repCrossRefTvDB = new CrossRef_AniDB_TvDBRepository();
List <CrossRef_AniDB_TvDB> xrefsTvDBProcessed = new List <CrossRef_AniDB_TvDB>();
List <CrossRef_AniDB_TvDB> xrefsTvDBToBeDeleted = new List <CrossRef_AniDB_TvDB>();
List <CrossRef_AniDB_TvDB> xrefsTvDB = repCrossRefTvDB.GetAll();
foreach (CrossRef_AniDB_TvDB xrefTvDB in xrefsTvDB)
{
bool deleteXref = false;
foreach (CrossRef_AniDB_TvDB xref in xrefsTvDBProcessed)
{
if (xref.TvDBID == xrefTvDB.TvDBID && xref.TvDBSeasonNumber == xrefTvDB.TvDBSeasonNumber)
{
xrefsTvDBToBeDeleted.Add(xrefTvDB);
deleteXref = true;
}
}
if (!deleteXref)
{
xrefsTvDBProcessed.Add(xrefTvDB);
}
}
foreach (CrossRef_AniDB_TvDB xref in xrefsTvDBToBeDeleted)
{
string msg = "";
AniDB_Anime anime = repAnime.GetByAnimeID(xref.AnimeID);
if (anime != null)
{
msg = anime.MainTitle;
}
logger.Warn("Deleting TvDB Link because of a duplicate: {0} ({1}) - {2}/{3}", xref.AnimeID, msg,
xref.TvDBID,
xref.TvDBSeasonNumber);
repCrossRefTvDB.Delete(xref.CrossRef_AniDB_TvDBID);
}
}
public static void CheckForAniDBFileUpdate(bool forceRefresh)
{
if (ServerSettings.AniDB_File_UpdateFrequency == ScheduledUpdateFrequency.Never && !forceRefresh) return;
int freqHours = Utils.GetScheduledHours(ServerSettings.AniDB_File_UpdateFrequency);
// check for any updated anime info every 12 hours
ScheduledUpdateRepository repSched = new ScheduledUpdateRepository();
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
ScheduledUpdate sched = repSched.GetByUpdateType((int)ScheduledUpdateType.AniDBFileUpdates);
if (sched != null)
{
// 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;
}
}
UpdateAniDBFileData(true, false, false);
// files which have been hashed, but don't have an associated episode
VideoLocalRepository repVidLocals = new VideoLocalRepository();
List<VideoLocal> filesWithoutEpisode = repVidLocals.GetVideosWithoutEpisode();
foreach (VideoLocal vl in filesWithoutEpisode)
{
CommandRequest_ProcessFile cmd = new CommandRequest_ProcessFile(vl.VideoLocalID, true);
cmd.Save();
}
// now check for any files which have been manually linked and are less than 30 days old
if (sched == null)
{
sched = new ScheduledUpdate();
sched.UpdateType = (int)ScheduledUpdateType.AniDBFileUpdates;
sched.UpdateDetails = "";
}
sched.LastUpdate = DateTime.Now;
repSched.Save(sched);
}
private static void InitCache(this IDatabase db)
{
JMMUserRepository.InitCache();
AniDB_AnimeRepository.InitCache();
VideoInfoRepository.InitCache();
VideoLocalRepository.InitCache();
VideoLocal_UserRepository.InitCache();
List <GroupFilter> recalc = GroupFilterRepository.InitCache();
AnimeEpisodeRepository.InitCache();
AnimeEpisode_UserRepository.InitCache();
AnimeSeriesRepository.InitCache();
AnimeSeries_UserRepository.InitCache();
AnimeGroupRepository.InitCache();
AnimeGroup_UserRepository.InitCache();
GroupFilterRepository.InitCacheSecondPart(recalc);
DatabaseFixes.ExecuteDatabaseFixes();
db.CleanUpMemory();
}
public Contract_IgnoreAnime ToContract()
{
Contract_IgnoreAnime contract = new Contract_IgnoreAnime();
contract.IgnoreAnimeID = this.IgnoreAnimeID;
contract.JMMUserID = this.JMMUserID;
contract.AnimeID = this.AnimeID;
contract.IgnoreType = this.IgnoreType;
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(AnimeID);
if (anime != null)
{
contract.Anime = anime.ToContract();
}
return(contract);
}
public Contract_BookmarkedAnime ToContract()
{
Contract_BookmarkedAnime contract = new Contract_BookmarkedAnime();
contract.BookmarkedAnimeID = BookmarkedAnimeID;
contract.AnimeID = AnimeID;
contract.Priority = Priority;
contract.Notes = Notes;
contract.Downloading = Downloading;
contract.Anime = null;
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime an = repAnime.GetByAnimeID(AnimeID);
if (an != null)
{
contract.Anime = an.Contract.AniDBAnime;
}
return(contract);
}
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;
}
}
public static void CheckForAnimeUpdate(bool forceRefresh)
{
if (ServerSettings.AniDB_Anime_UpdateFrequency == ScheduledUpdateFrequency.Never && !forceRefresh) return;
int freqHours = Utils.GetScheduledHours(ServerSettings.AniDB_Anime_UpdateFrequency);
// check for any updated anime info every 12 hours
ScheduledUpdateRepository repSched = new ScheduledUpdateRepository();
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
ScheduledUpdate sched = repSched.GetByUpdateType((int)ScheduledUpdateType.AniDBUpdates);
if (sched != null)
{
// 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;
}
}
CommandRequest_GetUpdated cmd = new CommandRequest_GetUpdated(true);
cmd.Save();
}
public static void CheckForCalendarUpdate(bool forceRefresh)
{
if (ServerSettings.AniDB_Calendar_UpdateFrequency == ScheduledUpdateFrequency.Never && !forceRefresh) return;
int freqHours = Utils.GetScheduledHours(ServerSettings.AniDB_Calendar_UpdateFrequency);
// update the calendar every 12 hours
// we will always assume that an anime was downloaded via http first
ScheduledUpdateRepository repSched = new ScheduledUpdateRepository();
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
ScheduledUpdate sched = repSched.GetByUpdateType((int)ScheduledUpdateType.AniDBCalendar);
if (sched != null)
{
// 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;
}
}
CommandRequest_GetCalendar cmd = new CommandRequest_GetCalendar(forceRefresh);
cmd.Save();
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_TraktSearchAnime: {0}", AnimeID);
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
// first check if the user wants to use the web cache
if (ServerSettings.WebCache_Trakt_Get)
{
try
{
List <Contract_Azure_CrossRef_AniDB_Trakt> contracts =
new List <Contract_Azure_CrossRef_AniDB_Trakt>();
List <JMMServer.Providers.Azure.CrossRef_AniDB_Trakt> resultsCache =
JMMServer.Providers.Azure.AzureWebAPI.Get_CrossRefAniDBTrakt(AnimeID);
if (resultsCache != null && resultsCache.Count > 0)
{
foreach (JMMServer.Providers.Azure.CrossRef_AniDB_Trakt xref in resultsCache)
{
TraktV2ShowExtended showInfo = TraktTVHelper.GetShowInfoV2(xref.TraktID);
if (showInfo != null)
{
logger.Trace("Found trakt match on web cache for {0} - id = {1}", AnimeID,
showInfo.title);
TraktTVHelper.LinkAniDBTrakt(AnimeID, (enEpisodeType)xref.AniDBStartEpisodeType,
xref.AniDBStartEpisodeNumber,
xref.TraktID, xref.TraktSeasonNumber, xref.TraktStartEpisodeNumber, true);
return;
}
}
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
}
// lets try to see locally if we have a tvDB link for this anime
// Trakt allows the use of TvDB ID's or their own Trakt ID's
CrossRef_AniDB_TvDBV2Repository repCrossRefTvDB = new CrossRef_AniDB_TvDBV2Repository();
List <CrossRef_AniDB_TvDBV2> xrefTvDBs = repCrossRefTvDB.GetByAnimeID(session, AnimeID);
if (xrefTvDBs != null && xrefTvDBs.Count > 0)
{
foreach (CrossRef_AniDB_TvDBV2 tvXRef in xrefTvDBs)
{
// first search for this show by the TvDB ID
List <TraktV2SearchTvDBIDShowResult> searchResults =
TraktTVHelper.SearchShowByIDV2(TraktSearchIDType.tvdb,
tvXRef.TvDBID.ToString());
if (searchResults != null && searchResults.Count > 0)
{
// since we are searching by ID, there will only be one 'show' result
TraktV2Show resShow = null;
foreach (TraktV2SearchTvDBIDShowResult res in searchResults)
{
if (res.ResultType == SearchIDType.Show)
{
resShow = res.show;
break;
}
}
if (resShow != null)
{
TraktV2ShowExtended showInfo = TraktTVHelper.GetShowInfoV2(resShow.ids.slug);
if (showInfo != null && showInfo.ids != null)
{
// make sure the season specified by TvDB also exists on Trakt
Trakt_ShowRepository repShow = new Trakt_ShowRepository();
Trakt_Show traktShow = repShow.GetByTraktSlug(session, showInfo.ids.slug);
if (traktShow != null)
{
Trakt_SeasonRepository repSeasons = new Trakt_SeasonRepository();
Trakt_Season traktSeason = repSeasons.GetByShowIDAndSeason(session,
traktShow.Trakt_ShowID,
xrefTvDBs[0].TvDBSeasonNumber);
if (traktSeason != null)
{
logger.Trace("Found trakt match using TvDBID locally {0} - id = {1}",
AnimeID, showInfo.title);
TraktTVHelper.LinkAniDBTrakt(AnimeID,
(AniDBAPI.enEpisodeType)tvXRef.AniDBStartEpisodeType,
tvXRef.AniDBStartEpisodeNumber, showInfo.ids.slug,
tvXRef.TvDBSeasonNumber, tvXRef.TvDBStartEpisodeNumber,
true);
return;
}
}
}
}
}
}
}
// finally lets try searching Trakt directly
string searchCriteria = "";
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(session, 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 <TraktV2SearchShowResult> results = TraktTVHelper.SearchShowV2(searchCriteria);
logger.Trace("Found {0} trakt results for {1} ", results.Count, searchCriteria);
if (ProcessSearchResults(session, results, searchCriteria))
{
return;
}
if (results.Count == 0)
{
foreach (AniDB_Anime_Title title in anime.GetTitles(session))
{
if (title.TitleType.ToUpper() != Constants.AnimeTitleType.Official.ToUpper())
{
continue;
}
if (searchCriteria.ToUpper() == title.Title.ToUpper())
{
continue;
}
results = TraktTVHelper.SearchShowV2(searchCriteria);
logger.Trace("Found {0} trakt results for search on {1}", results.Count, title.Title);
if (ProcessSearchResults(session, results, title.Title))
{
return;
}
}
}
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_TvDBSearchAnime: {0} - {1}", AnimeID, ex.ToString());
return;
}
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_DownloadImage: {0}", EntityID);
string downloadURL = "";
try
{
ImageDownloadRequest req = null;
switch (EntityTypeEnum)
{
case JMMImageType.AniDB_Cover:
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByID(EntityID);
if (anime == null)
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, anime, ForceDownload);
break;
case JMMImageType.TvDB_Episode:
TvDB_EpisodeRepository repTvEp = new TvDB_EpisodeRepository();
TvDB_Episode ep = repTvEp.GetByID(EntityID);
if (ep == null)
{
return;
}
if (string.IsNullOrEmpty(ep.Filename))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, ep, ForceDownload);
break;
case JMMImageType.TvDB_FanArt:
TvDB_ImageFanartRepository repFanart = new TvDB_ImageFanartRepository();
TvDB_ImageFanart fanart = repFanart.GetByID(EntityID);
if (fanart == null)
{
return;
}
if (string.IsNullOrEmpty(fanart.BannerPath))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, fanart, ForceDownload);
break;
case JMMImageType.TvDB_Cover:
TvDB_ImagePosterRepository repPoster = new TvDB_ImagePosterRepository();
TvDB_ImagePoster poster = repPoster.GetByID(EntityID);
if (poster == null)
{
return;
}
if (string.IsNullOrEmpty(poster.BannerPath))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, poster, ForceDownload);
break;
case JMMImageType.TvDB_Banner:
TvDB_ImageWideBannerRepository repBanners = new TvDB_ImageWideBannerRepository();
TvDB_ImageWideBanner wideBanner = repBanners.GetByID(EntityID);
if (wideBanner == null)
{
return;
}
if (string.IsNullOrEmpty(wideBanner.BannerPath))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, wideBanner, ForceDownload);
break;
case JMMImageType.MovieDB_Poster:
MovieDB_PosterRepository repMoviePosters = new MovieDB_PosterRepository();
MovieDB_Poster moviePoster = repMoviePosters.GetByID(EntityID);
if (moviePoster == null)
{
return;
}
if (string.IsNullOrEmpty(moviePoster.URL))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, moviePoster, ForceDownload);
break;
case JMMImageType.MovieDB_FanArt:
MovieDB_FanartRepository repMovieFanart = new MovieDB_FanartRepository();
MovieDB_Fanart movieFanart = repMovieFanart.GetByID(EntityID);
if (movieFanart == null)
{
return;
}
if (string.IsNullOrEmpty(movieFanart.URL))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, movieFanart, ForceDownload);
break;
case JMMImageType.Trakt_Poster:
Trakt_ImagePosterRepository repTraktPosters = new Trakt_ImagePosterRepository();
Trakt_ImagePoster traktPoster = repTraktPosters.GetByID(EntityID);
if (traktPoster == null)
{
return;
}
if (string.IsNullOrEmpty(traktPoster.ImageURL))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, traktPoster, ForceDownload);
break;
case JMMImageType.Trakt_Fanart:
Trakt_ImageFanartRepository repTraktFanarts = new Trakt_ImageFanartRepository();
Trakt_ImageFanart traktFanart = repTraktFanarts.GetByID(EntityID);
if (traktFanart == null)
{
return;
}
if (string.IsNullOrEmpty(traktFanart.ImageURL))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, traktFanart, ForceDownload);
break;
case JMMImageType.Trakt_Friend:
Trakt_FriendRepository repFriends = new Trakt_FriendRepository();
Trakt_Friend friend = repFriends.GetByID(EntityID);
if (friend == null)
{
return;
}
if (string.IsNullOrEmpty(friend.Avatar))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, friend, ForceDownload);
break;
case JMMImageType.Trakt_Episode:
Trakt_EpisodeRepository repTraktEpisodes = new Trakt_EpisodeRepository();
Trakt_Episode traktEp = repTraktEpisodes.GetByID(EntityID);
if (traktEp == null)
{
return;
}
if (string.IsNullOrEmpty(traktEp.EpisodeImage))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, traktEp, ForceDownload);
break;
case JMMImageType.AniDB_Character:
AniDB_CharacterRepository repChars = new AniDB_CharacterRepository();
AniDB_Character chr = repChars.GetByID(EntityID);
if (chr == null)
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, chr, ForceDownload);
break;
case JMMImageType.AniDB_Creator:
AniDB_SeiyuuRepository repCreator = new AniDB_SeiyuuRepository();
AniDB_Seiyuu creator = repCreator.GetByID(EntityID);
if (creator == null)
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, creator, ForceDownload);
break;
}
if (req == null)
{
return;
}
List <string> fileNames = new List <string>();
List <string> downloadURLs = new List <string>();
string fileNameTemp = GetFileName(req, false);
string downloadURLTemp = GetFileURL(req, false);
fileNames.Add(fileNameTemp);
downloadURLs.Add(downloadURLTemp);
if (req.ImageType == JMMImageType.TvDB_FanArt)
{
fileNameTemp = GetFileName(req, true);
downloadURLTemp = GetFileURL(req, true);
fileNames.Add(fileNameTemp);
downloadURLs.Add(downloadURLTemp);
}
for (int i = 0; i < fileNames.Count; i++)
{
string fileName = fileNames[i];
downloadURL = downloadURLs[i];
bool downloadImage = true;
bool fileExists = File.Exists(fileName);
if (fileExists)
{
if (!req.ForceDownload)
{
downloadImage = false;
}
else
{
downloadImage = true;
}
}
else
{
downloadImage = true;
}
if (downloadImage)
{
string tempName = Path.Combine(ImageUtils.GetImagesTempFolder(), Path.GetFileName(fileName));
if (File.Exists(tempName))
{
File.Delete(tempName);
}
try
{
if (fileExists)
{
File.Delete(fileName);
}
}
catch (Exception ex)
{
Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(ServerSettings.Culture);
string msg = string.Format(JMMServer.Properties.Resources.Command_DeleteError, fileName,
ex.Message);
logger.Warn(msg);
return;
}
// download image
using (WebClient client = new WebClient())
{
client.Headers.Add("user-agent", "JMM");
//OnImageDownloadEvent(new ImageDownloadEventArgs("", req, ImageDownloadEventType.Started));
//BaseConfig.MyAnimeLog.Write("ProcessImages: Download: {0} *** to *** {1}", req.URL, fullName);
if (downloadURL.Length > 0)
{
client.DownloadFile(downloadURL, tempName);
string extension = "";
string contentType = client.ResponseHeaders["Content-type"].ToLower();
if (contentType.IndexOf("gif") >= 0)
{
extension = ".gif";
}
if (contentType.IndexOf("jpg") >= 0)
{
extension = ".jpg";
}
if (contentType.IndexOf("jpeg") >= 0)
{
extension = ".jpg";
}
if (contentType.IndexOf("bmp") >= 0)
{
extension = ".bmp";
}
if (contentType.IndexOf("png") >= 0)
{
extension = ".png";
}
if (extension.Length > 0)
{
string newFile = Path.ChangeExtension(tempName, extension);
if (!newFile.ToLower().Equals(tempName.ToLower()))
{
try
{
System.IO.File.Delete(newFile);
}
catch
{
//BaseConfig.MyAnimeLog.Write("DownloadedImage:Download() Delete failed:{0}", newFile);
}
System.IO.File.Move(tempName, newFile);
tempName = newFile;
}
}
}
}
// move the file to it's final location
// check that the final folder exists
string fullPath = Path.GetDirectoryName(fileName);
if (!Directory.Exists(fullPath))
{
Directory.CreateDirectory(fullPath);
}
System.IO.File.Move(tempName, fileName);
logger.Info("Image downloaded: {0}", fileName);
}
}
}
catch (Exception ex)
{
logger.Warn("Error processing CommandRequest_DownloadImage: {0} ({1}) - {2}", downloadURL, EntityID,
ex.Message);
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);
cmdRelgrp.Save(session);
}
transaction.Commit();
}
}
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_GetReleaseGroupStatus: {0} - {1}", AnimeID, ex.ToString());
return;
}
}
public System.IO.Stream GetImage(string ImageType, string ImageID)
{
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
TvDB_ImagePosterRepository repPosters = new TvDB_ImagePosterRepository();
TvDB_EpisodeRepository repEpisodes = new TvDB_EpisodeRepository();
TvDB_ImageFanartRepository repFanart = new TvDB_ImageFanartRepository();
TvDB_ImageWideBannerRepository repWideBanners = new TvDB_ImageWideBannerRepository();
MovieDB_PosterRepository repMoviePosters = new MovieDB_PosterRepository();
MovieDB_FanartRepository repMovieFanart = new MovieDB_FanartRepository();
Trakt_ImageFanartRepository repTraktFanart = new Trakt_ImageFanartRepository();
Trakt_ImagePosterRepository repTraktPosters = new Trakt_ImagePosterRepository();
Trakt_EpisodeRepository repTraktEpisodes = new Trakt_EpisodeRepository();
Trakt_FriendRepository repTraktFriends = new Trakt_FriendRepository();
JMMImageType imageType = (JMMImageType)int.Parse(ImageType);
switch (imageType)
{
case JMMImageType.AniDB_Cover:
AniDB_Anime anime = repAnime.GetByAnimeID(int.Parse(ImageID));
if (anime == null)
{
return(null);
}
if (File.Exists(anime.PosterPath))
{
FileStream fs = File.OpenRead(anime.PosterPath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find AniDB_Cover image: {0}", anime.PosterPath);
return(BlankImage());
}
case JMMImageType.AniDB_Character:
AniDB_CharacterRepository repChar = new AniDB_CharacterRepository();
AniDB_Character chr = repChar.GetByID(int.Parse(ImageID));
if (chr == null)
{
return(null);
}
if (File.Exists(chr.PosterPath))
{
FileStream fs = File.OpenRead(chr.PosterPath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find AniDB_Character image: {0}", chr.PosterPath);
return(BlankImage());
}
case JMMImageType.AniDB_Creator:
AniDB_SeiyuuRepository repCreator = new AniDB_SeiyuuRepository();
AniDB_Seiyuu creator = repCreator.GetByID(int.Parse(ImageID));
if (creator == null)
{
return(null);
}
if (File.Exists(creator.PosterPath))
{
FileStream fs = File.OpenRead(creator.PosterPath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find AniDB_Creator image: {0}", creator.PosterPath);
return(BlankImage());
}
case JMMImageType.TvDB_Cover:
TvDB_ImagePoster poster = repPosters.GetByID(int.Parse(ImageID));
if (poster == null)
{
return(null);
}
if (File.Exists(poster.FullImagePath))
{
FileStream fs = File.OpenRead(poster.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find TvDB_Cover image: {0}", poster.FullImagePath);
return(BlankImage());
}
case JMMImageType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = repWideBanners.GetByID(int.Parse(ImageID));
if (wideBanner == null)
{
return(null);
}
if (File.Exists(wideBanner.FullImagePath))
{
FileStream fs = File.OpenRead(wideBanner.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find TvDB_Banner image: {0}", wideBanner.FullImagePath);
return(BlankImage());
}
case JMMImageType.TvDB_Episode:
TvDB_Episode ep = repEpisodes.GetByID(int.Parse(ImageID));
if (ep == null)
{
return(null);
}
if (File.Exists(ep.FullImagePath))
{
FileStream fs = File.OpenRead(ep.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find TvDB_Episode image: {0}", ep.FullImagePath);
return(BlankImage());
}
case JMMImageType.TvDB_FanArt:
TvDB_ImageFanart fanart = repFanart.GetByID(int.Parse(ImageID));
if (fanart == null)
{
return(null);
}
if (File.Exists(fanart.FullImagePath))
{
FileStream fs = File.OpenRead(fanart.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find TvDB_FanArt image: {0}", fanart.FullImagePath);
return(BlankImage());
}
case JMMImageType.MovieDB_Poster:
MovieDB_Poster mPoster = repMoviePosters.GetByID(int.Parse(ImageID));
if (mPoster == null)
{
return(null);
}
// now find only the original size
mPoster = repMoviePosters.GetByOnlineID(mPoster.URL);
if (mPoster == null)
{
return(null);
}
if (File.Exists(mPoster.FullImagePath))
{
FileStream fs = File.OpenRead(mPoster.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find MovieDB_Poster image: {0}", mPoster.FullImagePath);
return(BlankImage());
}
case JMMImageType.MovieDB_FanArt:
MovieDB_Fanart mFanart = repMovieFanart.GetByID(int.Parse(ImageID));
if (mFanart == null)
{
return(null);
}
mFanart = repMovieFanart.GetByOnlineID(mFanart.URL);
if (mFanart == null)
{
return(null);
}
if (File.Exists(mFanart.FullImagePath))
{
FileStream fs = File.OpenRead(mFanart.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find MovieDB_FanArt image: {0}", mFanart.FullImagePath);
return(BlankImage());
}
case JMMImageType.Trakt_Fanart:
Trakt_ImageFanart tFanart = repTraktFanart.GetByID(int.Parse(ImageID));
if (tFanart == null)
{
return(null);
}
if (File.Exists(tFanart.FullImagePath))
{
FileStream fs = File.OpenRead(tFanart.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find Trakt_Fanart image: {0}", tFanart.FullImagePath);
return(BlankImage());
}
case JMMImageType.Trakt_Poster:
Trakt_ImagePoster tPoster = repTraktPosters.GetByID(int.Parse(ImageID));
if (tPoster == null)
{
return(null);
}
if (File.Exists(tPoster.FullImagePath))
{
FileStream fs = File.OpenRead(tPoster.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find Trakt_Poster image: {0}", tPoster.FullImagePath);
return(BlankImage());
}
case JMMImageType.Trakt_Episode:
case JMMImageType.Trakt_WatchedEpisode:
Trakt_Episode tEpisode = repTraktEpisodes.GetByID(int.Parse(ImageID));
if (tEpisode == null)
{
return(null);
}
if (File.Exists(tEpisode.FullImagePath))
{
FileStream fs = File.OpenRead(tEpisode.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find Trakt_Episode image: {0}", tEpisode.FullImagePath);
return(BlankImage());
}
default:
return(BlankImage());
}
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_GetCalendar");
try
{
// we will always assume that an anime was downloaded via http first
ScheduledUpdateRepository repSched = new ScheduledUpdateRepository();
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
ScheduledUpdate sched = repSched.GetByUpdateType((int)ScheduledUpdateType.AniDBCalendar);
if (sched == null)
{
sched = new ScheduledUpdate();
sched.UpdateType = (int)ScheduledUpdateType.AniDBCalendar;
sched.UpdateDetails = "";
}
else
{
int freqHours = Utils.GetScheduledHours(ServerSettings.AniDB_Calendar_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;
}
}
}
sched.LastUpdate = DateTime.Now;
repSched.Save(sched);
CalendarCollection colCalendars = JMMService.AnidbProcessor.GetCalendarUDP();
if (colCalendars == null || colCalendars.Calendars == null)
{
logger.Error("Could not get calendar from AniDB");
return;
}
foreach (AniDBAPI.Calendar cal in colCalendars.Calendars)
{
AniDB_Anime anime = repAnime.GetByAnimeID(cal.AnimeID);
if (anime != null)
{
// don't update if the local data is less 2 days old
TimeSpan ts = DateTime.Now - anime.DateTimeUpdated;
if (ts.TotalDays >= 2)
{
CommandRequest_GetAnimeHTTP cmdAnime = new CommandRequest_GetAnimeHTTP(cal.AnimeID, true,
false);
cmdAnime.Save();
}
else
{
// update the release date even if we don't update the anime record
if (anime.AirDate != cal.ReleaseDate)
{
anime.AirDate = cal.ReleaseDate;
repAnime.Save(anime);
AnimeSeriesRepository srepo = new AnimeSeriesRepository();
AnimeSeries ser = srepo.GetByAnimeID(anime.AnimeID);
if (ser != null)
{
srepo.Save(ser, true, false);
}
}
}
}
else
{
CommandRequest_GetAnimeHTTP cmdAnime = new CommandRequest_GetAnimeHTTP(cal.AnimeID, true, false);
cmdAnime.Save();
}
}
}
catch (Exception ex)
{
logger.ErrorException("Error processing CommandRequest_GetCalendar: " + ex.ToString(), ex);
return;
}
}
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_MALSearchAnime: {0}", AnimeID);
try
{
// first check if the user wants to use the web cache
if (ServerSettings.WebCache_MAL_Get)
{
try
{
List <CrossRef_AniDB_MALResult> crossRefs = XMLService.Get_CrossRef_AniDB_MAL(AnimeID);
if (crossRefs != null)
{
foreach (CrossRef_AniDB_MALResult crossRef in crossRefs)
{
logger.Trace("Found MAL match on web cache for {0} - id = {1} ({2}/{3})", AnimeID, crossRef.MALID, crossRef.StartEpisodeType, crossRef.StartEpisodeNumber);
MALHelper.LinkAniDBMAL(AnimeID, crossRef.MALID, crossRef.MALTitle, crossRef.StartEpisodeType, crossRef.StartEpisodeNumber, true);
}
return;
}
}
catch (Exception)
{
}
}
string searchCriteria = "";
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.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
anime malResults = MALHelper.SearchAnimesByTitle(searchCriteria);
if (malResults.entry.Length == 1)
{
logger.Trace("Using MAL search result for search on {0} : {1} ({2})", searchCriteria, malResults.entry[0].id, malResults.entry[0].title);
MALHelper.LinkAniDBMAL(AnimeID, malResults.entry[0].id, malResults.entry[0].title, (int)enEpisodeType.Episode, 1, false);
}
else if (malResults.entry.Length == 0)
{
logger.Trace("ZERO MAL search result results for: {0}", searchCriteria);
}
else
{
// if the title's match exactly and they have the same amount of episodes, we will use it
foreach (animeEntry res in malResults.entry)
{
if (res.title.Equals(anime.MainTitle, StringComparison.InvariantCultureIgnoreCase) && res.episodes == anime.EpisodeCountNormal)
{
logger.Trace("Using MAL search result for search on {0} : {1} ({2})", searchCriteria, res.id, res.title);
MALHelper.LinkAniDBMAL(AnimeID, res.id, res.title, (int)enEpisodeType.Episode, 1, false);
}
}
logger.Trace("Too many MAL search result results for, skipping: {0}", searchCriteria);
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_MALSearchAnime: {0} - {1}", AnimeID, ex.ToString());
return;
}
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_TraktSearchAnime: {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
{
CrossRef_AniDB_TraktResult crossRef = XMLService.Get_CrossRef_AniDB_Trakt(AnimeID);
if (crossRef != null)
{
TraktTVShow showInfo = TraktTVHelper.GetShowInfo(crossRef.TraktID);
if (showInfo != null)
{
logger.Trace("Found trakt match on web cache for {0} - id = {1}", AnimeID, showInfo.title);
TraktTVHelper.LinkAniDBTrakt(AnimeID, crossRef.TraktID, crossRef.TraktSeasonNumber, true);
return;
}
}
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
}
// lets try to see locally if we have a tvDB link for this anime
// Trakt allows the use of TvDB ID's or their own Trakt ID's
CrossRef_AniDB_TvDBV2Repository repCrossRefTvDB = new CrossRef_AniDB_TvDBV2Repository();
List <CrossRef_AniDB_TvDBV2> xrefTvDBs = repCrossRefTvDB.GetByAnimeID(session, AnimeID);
if (xrefTvDBs != null && xrefTvDBs.Count == 1) //TODO this is temporary code, until trakt also allows multiple links
{
TraktTVShow showInfo = TraktTVHelper.GetShowInfo(xrefTvDBs[0].TvDBID);
if (showInfo != null)
{
// make sure the season specified by TvDB also exists on Trakt
Trakt_ShowRepository repShow = new Trakt_ShowRepository();
Trakt_Show traktShow = repShow.GetByTraktID(session, showInfo.TraktID);
if (traktShow != null)
{
Trakt_SeasonRepository repSeasons = new Trakt_SeasonRepository();
Trakt_Season traktSeason = repSeasons.GetByShowIDAndSeason(session, traktShow.Trakt_ShowID, xrefTvDBs[0].TvDBSeasonNumber);
if (traktSeason != null)
{
logger.Trace("Found trakt match using TvDBID locally {0} - id = {1}", AnimeID, showInfo.title);
TraktTVHelper.LinkAniDBTrakt(AnimeID, showInfo.TraktID, traktSeason.Season, true);
return;
}
}
}
}
// if not lets try the tvdb web cache based on the same reasoning
if (ServerSettings.WebCache_TvDB_Get)
{
List <JMMServer.Providers.Azure.CrossRef_AniDB_TvDB> cacheResults = JMMServer.Providers.Azure.AzureWebAPI.Get_CrossRefAniDBTvDB(AnimeID);
if (cacheResults != null && cacheResults.Count > 0)
{
TraktTVShow showInfo = TraktTVHelper.GetShowInfo(cacheResults[0].TvDBID);
if (showInfo != null)
{
// make sure the season specified by TvDB also exists on Trakt
Trakt_ShowRepository repShow = new Trakt_ShowRepository();
Trakt_Show traktShow = repShow.GetByTraktID(session, showInfo.TraktID);
if (traktShow != null)
{
Trakt_SeasonRepository repSeasons = new Trakt_SeasonRepository();
Trakt_Season traktSeason = repSeasons.GetByShowIDAndSeason(session, traktShow.Trakt_ShowID, cacheResults[0].TvDBSeasonNumber);
if (traktSeason != null)
{
logger.Trace("Found trakt match on web cache by using TvDBID {0} - id = {1}", AnimeID, showInfo.title);
TraktTVHelper.LinkAniDBTrakt(AnimeID, showInfo.TraktID, traktSeason.Season, true);
return;
}
}
}
}
}
// finally lets try searching Trakt directly
string searchCriteria = "";
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByAnimeID(session, 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 <TraktTVShow> results = TraktTVHelper.SearchShow(searchCriteria);
logger.Trace("Found {0} trakt results for {1} ", results.Count, searchCriteria);
if (ProcessSearchResults(session, results, searchCriteria))
{
return;
}
if (results.Count == 0)
{
foreach (AniDB_Anime_Title title in anime.GetTitles(session))
{
if (title.TitleType.ToUpper() != Constants.AnimeTitleType.Official.ToUpper())
{
continue;
}
if (searchCriteria.ToUpper() == title.Title.ToUpper())
{
continue;
}
results = TraktTVHelper.SearchShow(searchCriteria);
logger.Trace("Found {0} trakt results for search on {1}", results.Count, title.Title);
if (ProcessSearchResults(session, results, title.Title))
{
return;
}
}
}
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_TvDBSearchAnime: {0} - {1}", AnimeID, ex.ToString());
return;
}
}
