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)
{
List <JMMServer.Providers.Azure.CrossRef_File_Episode> xrefs = JMMServer.Providers.Azure.AzureWebAPI.Get_CrossRefFileEpisode(vidLocal);
crossRefs = new List <CrossRef_File_Episode>();
if (xrefs == null || xrefs.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 (JMMServer.Providers.Azure.CrossRef_File_Episode xref in xrefs)
{
CrossRef_File_Episode xrefEnt = new CrossRef_File_Episode();
xrefEnt.Hash = vidLocal.ED2KHash;
xrefEnt.FileName = Path.GetFileName(vidLocal.FullServerPath);
xrefEnt.FileSize = vidLocal.FileSize;
xrefEnt.CrossRefSource = (int)JMMServer.CrossRefSource.WebCache;
xrefEnt.AnimeID = animeID;
xrefEnt.EpisodeID = xref.EpisodeID;
xrefEnt.Percentage = xref.Percentage;
xrefEnt.EpisodeOrder = xref.EpisodeOrder;
crossRefs.Add(xrefEnt);
// in this case we need to save the cross refs manually as AniDB did not provide them
repXrefFE.Save(xrefEnt);
}
}
}
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....");
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)
{
if (ServerSettings.WebCache_Trakt_Send && !string.IsNullOrEmpty(ServerSettings.Trakt_Username))
{
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 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 void UpdateStats(bool watchedStats, bool missingEpsStats, bool updateAllGroupsAbove)
{
DateTime start = DateTime.Now;
DateTime startOverall = DateTime.Now;
logger.Info("Starting Updating STATS for SERIES {0} ({1} - {2} - {3})", this.ToString(), watchedStats, missingEpsStats, updateAllGroupsAbove);
AnimeSeries_UserRepository repSeriesUser = new AnimeSeries_UserRepository();
AnimeEpisode_UserRepository repEpisodeUser = new AnimeEpisode_UserRepository();
VideoLocalRepository repVids = new VideoLocalRepository();
CrossRef_File_EpisodeRepository repXrefs = new CrossRef_File_EpisodeRepository();
JMMUserRepository repUsers = new JMMUserRepository();
List <JMMUser> allUsers = repUsers.GetAll();
DateTime startEps = DateTime.Now;
List <AnimeEpisode> eps = GetAnimeEpisodes();
TimeSpan tsEps = DateTime.Now - startEps;
logger.Trace("Got episodes for SERIES {0} in {1}ms", this.ToString(), tsEps.TotalMilliseconds);
DateTime startVids = DateTime.Now;
List <VideoLocal> vidsTemp = repVids.GetByAniDBAnimeID(this.AniDB_ID);
List <CrossRef_File_Episode> crossRefs = repXrefs.GetByAnimeID(this.AniDB_ID);
Dictionary <int, List <CrossRef_File_Episode> > dictCrossRefs = new Dictionary <int, List <CrossRef_File_Episode> >();
foreach (CrossRef_File_Episode xref in crossRefs)
{
if (!dictCrossRefs.ContainsKey(xref.EpisodeID))
{
dictCrossRefs[xref.EpisodeID] = new List <CrossRef_File_Episode>();
}
dictCrossRefs[xref.EpisodeID].Add(xref);
}
Dictionary <string, VideoLocal> dictVids = new Dictionary <string, VideoLocal>();
foreach (VideoLocal vid in vidsTemp)
{
dictVids[vid.Hash] = vid;
}
TimeSpan tsVids = DateTime.Now - startVids;
logger.Trace("Got video locals for SERIES {0} in {1}ms", this.ToString(), tsVids.TotalMilliseconds);
if (watchedStats)
{
foreach (JMMUser juser in allUsers)
{
//this.WatchedCount = 0;
AnimeSeries_User userRecord = GetUserRecord(juser.JMMUserID);
if (userRecord == null)
{
userRecord = new AnimeSeries_User(juser.JMMUserID, this.AnimeSeriesID);
}
// reset stats
userRecord.UnwatchedEpisodeCount = 0;
userRecord.WatchedEpisodeCount = 0;
userRecord.WatchedCount = 0;
userRecord.WatchedDate = null;
DateTime startUser = DateTime.Now;
List <AnimeEpisode_User> epUserRecords = repEpisodeUser.GetByUserID(juser.JMMUserID);
Dictionary <int, AnimeEpisode_User> dictUserRecords = new Dictionary <int, AnimeEpisode_User>();
foreach (AnimeEpisode_User usrec in epUserRecords)
{
dictUserRecords[usrec.AnimeEpisodeID] = usrec;
}
TimeSpan tsUser = DateTime.Now - startUser;
logger.Trace("Got user records for SERIES {0}/{1} in {2}ms", this.ToString(), juser.Username, tsUser.TotalMilliseconds);
foreach (AnimeEpisode ep in eps)
{
// if the episode doesn't have any files then it won't count towards watched/unwatched counts
List <VideoLocal> epVids = new List <VideoLocal>();
if (dictCrossRefs.ContainsKey(ep.AniDB_EpisodeID))
{
foreach (CrossRef_File_Episode xref in dictCrossRefs[ep.AniDB_EpisodeID])
{
if (xref.EpisodeID == ep.AniDB_EpisodeID)
{
if (dictVids.ContainsKey(xref.Hash))
{
epVids.Add(dictVids[xref.Hash]);
}
}
}
}
if (epVids.Count == 0)
{
continue;
}
if (ep.EpisodeTypeEnum == AniDBAPI.enEpisodeType.Episode || ep.EpisodeTypeEnum == AniDBAPI.enEpisodeType.Special)
{
AnimeEpisode_User epUserRecord = null;
if (dictUserRecords.ContainsKey(ep.AnimeEpisodeID))
{
epUserRecord = dictUserRecords[ep.AnimeEpisodeID];
}
if (epUserRecord != null && epUserRecord.WatchedDate.HasValue)
{
userRecord.WatchedEpisodeCount++;
}
else
{
userRecord.UnwatchedEpisodeCount++;
}
if (epUserRecord != null)
{
if (userRecord.WatchedDate.HasValue)
{
if (epUserRecord.WatchedDate > userRecord.WatchedDate)
{
userRecord.WatchedDate = epUserRecord.WatchedDate;
}
}
else
{
userRecord.WatchedDate = epUserRecord.WatchedDate;
}
userRecord.WatchedCount += epUserRecord.WatchedCount;
}
}
}
repSeriesUser.Save(userRecord);
}
}
TimeSpan ts = DateTime.Now - start;
logger.Trace("Updated WATCHED stats for SERIES {0} in {1}ms", this.ToString(), ts.TotalMilliseconds);
start = DateTime.Now;
if (missingEpsStats)
{
enAnimeType animeType = enAnimeType.TVSeries;
AniDB_Anime aniDB_Anime = this.GetAnime();
if (aniDB_Anime != null)
{
animeType = aniDB_Anime.AnimeTypeEnum;
}
MissingEpisodeCount = 0;
MissingEpisodeCountGroups = 0;
// get all the group status records
AniDB_GroupStatusRepository repGrpStat = new AniDB_GroupStatusRepository();
List <AniDB_GroupStatus> grpStatuses = repGrpStat.GetByAnimeID(this.AniDB_ID);
// find all the episodes for which the user has a file
// from this we can determine what their latest episode number is
// find out which groups the user is collecting
List <int> userReleaseGroups = new List <int>();
foreach (AnimeEpisode ep in eps)
{
List <VideoLocal> vids = new List <VideoLocal>();
if (dictCrossRefs.ContainsKey(ep.AniDB_EpisodeID))
{
foreach (CrossRef_File_Episode xref in dictCrossRefs[ep.AniDB_EpisodeID])
{
if (xref.EpisodeID == ep.AniDB_EpisodeID)
{
if (dictVids.ContainsKey(xref.Hash))
{
vids.Add(dictVids[xref.Hash]);
}
}
}
}
//List<VideoLocal> vids = ep.VideoLocals;
foreach (VideoLocal vid in vids)
{
AniDB_File anifile = vid.GetAniDBFile();
if (anifile != null)
{
if (!userReleaseGroups.Contains(anifile.GroupID))
{
userReleaseGroups.Add(anifile.GroupID);
}
}
}
}
int latestLocalEpNumber = 0;
EpisodeList epReleasedList = new EpisodeList(animeType);
EpisodeList epGroupReleasedList = new EpisodeList(animeType);
foreach (AnimeEpisode ep in eps)
{
//List<VideoLocal> vids = ep.VideoLocals;
if (ep.EpisodeTypeEnum != AniDBAPI.enEpisodeType.Episode)
{
continue;
}
List <VideoLocal> vids = new List <VideoLocal>();
if (dictCrossRefs.ContainsKey(ep.AniDB_EpisodeID))
{
foreach (CrossRef_File_Episode xref in dictCrossRefs[ep.AniDB_EpisodeID])
{
if (xref.EpisodeID == ep.AniDB_EpisodeID)
{
if (dictVids.ContainsKey(xref.Hash))
{
vids.Add(dictVids[xref.Hash]);
}
}
}
}
AniDB_Episode aniEp = ep.AniDB_Episode;
int thisEpNum = aniEp.EpisodeNumber;
if (thisEpNum > latestLocalEpNumber && vids.Count > 0)
{
latestLocalEpNumber = thisEpNum;
}
// does this episode have a file released
// does this episode have a file released by the group the user is collecting
bool epReleased = false;
bool epReleasedGroup = false;
foreach (AniDB_GroupStatus gs in grpStatuses)
{
if (gs.LastEpisodeNumber >= thisEpNum)
{
epReleased = true;
}
if (userReleaseGroups.Contains(gs.GroupID) && gs.HasGroupReleasedEpisode(thisEpNum))
{
epReleasedGroup = true;
}
}
try
{
epReleasedList.Add(ep, (!epReleased || vids.Count != 0));
epGroupReleasedList.Add(ep, (!epReleasedGroup || vids.Count != 0));
}
catch (Exception e)
{
logger.Trace("Error {0}", e.ToString());
throw;
}
}
foreach (EpisodeList.StatEpisodes eplst in epReleasedList)
{
if (!eplst.Available)
{
MissingEpisodeCount++;
}
}
foreach (EpisodeList.StatEpisodes eplst in epGroupReleasedList)
{
if (!eplst.Available)
{
MissingEpisodeCountGroups++;
}
}
this.LatestLocalEpisodeNumber = latestLocalEpNumber;
}
ts = DateTime.Now - start;
logger.Trace("Updated MISSING EPS stats for SERIES {0} in {1}ms", this.ToString(), ts.TotalMilliseconds);
start = DateTime.Now;
AnimeSeriesRepository rep = new AnimeSeriesRepository();
rep.Save(this);
if (updateAllGroupsAbove)
{
foreach (AnimeGroup grp in AllGroupsAbove)
{
grp.UpdateStats(watchedStats, missingEpsStats);
}
}
ts = DateTime.Now - start;
logger.Trace("Updated GROUPS ABOVE stats for SERIES {0} in {1}ms", this.ToString(), ts.TotalMilliseconds);
start = DateTime.Now;
TimeSpan tsOverall = DateTime.Now - startOverall;
logger.Info("Finished Updating STATS for SERIES {0} in {1}ms ({2} - {3} - {4})", this.ToString(), tsOverall.TotalMilliseconds,
watchedStats, missingEpsStats, updateAllGroupsAbove);
}