public string GetImagePath(string ImageType, string ImageID, bool thumnbnailOnly)
{
JMMImageType imageType = (JMMImageType)int.Parse(ImageType);
switch (imageType)
{
case JMMImageType.AniDB_Cover:
AniDB_Anime anime = RepoFactory.AniDB_Anime.GetByAnimeID(int.Parse(ImageID));
if (anime == null)
{
return(null);
}
if (File.Exists(anime.PosterPath))
{
return(anime.PosterPath);
}
else
{
logger.Trace("Could not find AniDB_Cover image: {0}", anime.PosterPath);
return("");
}
case JMMImageType.AniDB_Character:
AniDB_Character chr = RepoFactory.AniDB_Character.GetByID(int.Parse(ImageID));
if (chr == null)
{
return(null);
}
if (File.Exists(chr.PosterPath))
{
return(chr.PosterPath);
}
else
{
logger.Trace("Could not find AniDB_Character image: {0}", chr.PosterPath);
return("");
}
case JMMImageType.AniDB_Creator:
AniDB_Seiyuu creator = RepoFactory.AniDB_Seiyuu.GetByID(int.Parse(ImageID));
if (creator == null)
{
return("");
}
if (File.Exists(creator.PosterPath))
{
return(creator.PosterPath);
}
else
{
logger.Trace("Could not find AniDB_Creator image: {0}", creator.PosterPath);
return("");
}
case JMMImageType.TvDB_Cover:
TvDB_ImagePoster poster = RepoFactory.TvDB_ImagePoster.GetByID(int.Parse(ImageID));
if (poster == null)
{
return(null);
}
if (File.Exists(poster.FullImagePath))
{
return(poster.FullImagePath);
}
else
{
logger.Trace("Could not find TvDB_Cover image: {0}", poster.FullImagePath);
return("");
}
case JMMImageType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = RepoFactory.TvDB_ImageWideBanner.GetByID(int.Parse(ImageID));
if (wideBanner == null)
{
return(null);
}
if (File.Exists(wideBanner.FullImagePath))
{
return(wideBanner.FullImagePath);
}
else
{
logger.Trace("Could not find TvDB_Banner image: {0}", wideBanner.FullImagePath);
return("");
}
case JMMImageType.TvDB_Episode:
TvDB_Episode ep = RepoFactory.TvDB_Episode.GetByID(int.Parse(ImageID));
if (ep == null)
{
return(null);
}
if (File.Exists(ep.FullImagePath))
{
return(ep.FullImagePath);
}
else
{
logger.Trace("Could not find TvDB_Episode image: {0}", ep.FullImagePath);
return("");
}
case JMMImageType.TvDB_FanArt:
TvDB_ImageFanart fanart = RepoFactory.TvDB_ImageFanart.GetByID(int.Parse(ImageID));
if (fanart == null)
{
return(null);
}
if (thumnbnailOnly)
{
if (File.Exists(fanart.FullThumbnailPath))
{
return(fanart.FullThumbnailPath);
}
else
{
logger.Trace("Could not find TvDB_FanArt image: {0}", fanart.FullThumbnailPath);
return("");
}
}
else
{
if (File.Exists(fanart.FullImagePath))
{
return(fanart.FullImagePath);
}
else
{
logger.Trace("Could not find TvDB_FanArt image: {0}", fanart.FullImagePath);
return("");
}
}
case JMMImageType.MovieDB_Poster:
MovieDB_Poster mPoster = RepoFactory.MovieDB_Poster.GetByID(int.Parse(ImageID));
if (mPoster == null)
{
return(null);
}
// now find only the original size
mPoster = RepoFactory.MovieDB_Poster.GetByOnlineID(mPoster.URL);
if (mPoster == null)
{
return(null);
}
if (File.Exists(mPoster.FullImagePath))
{
return(mPoster.FullImagePath);
}
else
{
logger.Trace("Could not find MovieDB_Poster image: {0}", mPoster.FullImagePath);
return("");
}
case JMMImageType.MovieDB_FanArt:
MovieDB_Fanart mFanart = RepoFactory.MovieDB_Fanart.GetByID(int.Parse(ImageID));
if (mFanart == null)
{
return(null);
}
mFanart = RepoFactory.MovieDB_Fanart.GetByOnlineID(mFanart.URL);
if (mFanart == null)
{
return(null);
}
if (File.Exists(mFanart.FullImagePath))
{
return(mFanart.FullImagePath);
}
else
{
logger.Trace("Could not find MovieDB_FanArt image: {0}", mFanart.FullImagePath);
return("");
}
case JMMImageType.Trakt_Fanart:
Trakt_ImageFanart tFanart = RepoFactory.Trakt_ImageFanart.GetByID(int.Parse(ImageID));
if (tFanart == null)
{
return(null);
}
if (File.Exists(tFanart.FullImagePath))
{
return(tFanart.FullImagePath);
}
else
{
logger.Trace("Could not find Trakt_Fanart image: {0}", tFanart.FullImagePath);
return("");
}
case JMMImageType.Trakt_Poster:
Trakt_ImagePoster tPoster = RepoFactory.Trakt_ImagePoster.GetByID(int.Parse(ImageID));
if (tPoster == null)
{
return(null);
}
if (File.Exists(tPoster.FullImagePath))
{
return(tPoster.FullImagePath);
}
else
{
logger.Trace("Could not find Trakt_Poster image: {0}", tPoster.FullImagePath);
return("");
}
case JMMImageType.Trakt_Episode:
case JMMImageType.Trakt_WatchedEpisode:
Trakt_Episode tEpisode = RepoFactory.Trakt_Episode.GetByID(int.Parse(ImageID));
if (tEpisode == null)
{
return(null);
}
if (File.Exists(tEpisode.FullImagePath))
{
return(tEpisode.FullImagePath);
}
else
{
logger.Trace("Could not find Trakt_Episode image: {0}", tEpisode.FullImagePath);
return("");
}
default:
return("");
}
}
public static List <AnimeGroup> GetRelatedGroupsFromAnimeID(ISession session, int animeid)
{
AniDB_AnimeRepository repAniAnime = new AniDB_AnimeRepository();
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeGroupRepository repGroups = new AnimeGroupRepository();
List <AnimeGroup> grps = new List <AnimeGroup>();
AniDB_Anime anime = repAniAnime.GetByAnimeID(session, animeid);
if (anime == null)
{
return(grps);
}
// first check for groups which are directly related
List <AniDB_Anime_Relation> relations = anime.GetRelatedAnime(session);
foreach (AniDB_Anime_Relation rel in relations)
{
string relationtype = rel.RelationType.ToLower();
if ((relationtype == "same setting") || (relationtype == "alternative setting") ||
(relationtype == "character") || (relationtype == "other"))
{
//Filter these relations these will fix messes, like Gundam , Clamp, etc.
continue;
}
// we actually need to get the series, because it might have been added to another group already
AnimeSeries ser = repSeries.GetByAnimeID(session, rel.RelatedAnimeID);
if (ser != null)
{
AnimeGroup grp = repGroups.GetByID(session, ser.AnimeGroupID);
if (grp != null)
{
grps.Add(grp);
}
}
}
if (grps.Count > 0)
{
return(grps);
}
// if nothing found check by all related anime
List <AniDB_Anime> relatedAnime = anime.GetAllRelatedAnime(session);
foreach (AniDB_Anime rel in relatedAnime)
{
// we actually need to get the series, because it might have been added to another group already
AnimeSeries ser = repSeries.GetByAnimeID(session, rel.AnimeID);
if (ser != null)
{
AnimeGroup grp = repGroups.GetByID(session, ser.AnimeGroupID);
if (grp != null)
{
grps.Add(grp);
}
}
}
return(grps);
}
public byte[] GetImage(string entityID, int entityType, bool thumnbnailOnly)
{
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)entityType;
switch (imageType)
{
case JMMImageType.AniDB_Cover:
AniDB_Anime anime = repAnime.GetByAnimeID(int.Parse(entityID));
if (anime == null)
{
return(null);
}
if (File.Exists(anime.PosterPath))
{
return(File.ReadAllBytes(anime.PosterPath));
}
else
{
logger.Trace("Could not find AniDB_Cover image: {0}", anime.PosterPath);
return(null);
}
case JMMImageType.AniDB_Character:
AniDB_CharacterRepository repChar = new AniDB_CharacterRepository();
AniDB_Character chr = repChar.GetByID(int.Parse(entityID));
if (chr == null)
{
return(null);
}
if (File.Exists(chr.PosterPath))
{
return(File.ReadAllBytes(chr.PosterPath));
}
else
{
logger.Trace("Could not find AniDB_Character image: {0}", chr.PosterPath);
return(null);
}
case JMMImageType.AniDB_Creator:
AniDB_SeiyuuRepository repCreator = new AniDB_SeiyuuRepository();
AniDB_Seiyuu creator = repCreator.GetByID(int.Parse(entityID));
if (creator == null)
{
return(null);
}
if (File.Exists(creator.PosterPath))
{
return(File.ReadAllBytes(creator.PosterPath));
}
else
{
logger.Trace("Could not find AniDB_Creator image: {0}", creator.PosterPath);
return(null);
}
case JMMImageType.TvDB_Cover:
TvDB_ImagePoster poster = repPosters.GetByID(int.Parse(entityID));
if (poster == null)
{
return(null);
}
if (File.Exists(poster.FullImagePath))
{
return(File.ReadAllBytes(poster.FullImagePath));
}
else
{
logger.Trace("Could not find TvDB_Cover image: {0}", poster.FullImagePath);
return(null);
}
case JMMImageType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = repWideBanners.GetByID(int.Parse(entityID));
if (wideBanner == null)
{
return(null);
}
if (File.Exists(wideBanner.FullImagePath))
{
return(File.ReadAllBytes(wideBanner.FullImagePath));
}
else
{
logger.Trace("Could not find TvDB_Banner image: {0}", wideBanner.FullImagePath);
return(null);
}
case JMMImageType.TvDB_Episode:
TvDB_Episode ep = repEpisodes.GetByID(int.Parse(entityID));
if (ep == null)
{
return(null);
}
if (File.Exists(ep.FullImagePath))
{
return(File.ReadAllBytes(ep.FullImagePath));
}
else
{
logger.Trace("Could not find TvDB_Episode image: {0}", ep.FullImagePath);
return(null);
}
case JMMImageType.TvDB_FanArt:
TvDB_ImageFanart fanart = repFanart.GetByID(int.Parse(entityID));
if (fanart == null)
{
return(null);
}
if (thumnbnailOnly)
{
if (File.Exists(fanart.FullThumbnailPath))
{
return(File.ReadAllBytes(fanart.FullThumbnailPath));
}
else
{
logger.Trace("Could not find TvDB_FanArt image: {0}", fanart.FullThumbnailPath);
return(null);
}
}
else
{
if (File.Exists(fanart.FullImagePath))
{
return(File.ReadAllBytes(fanart.FullImagePath));
}
else
{
logger.Trace("Could not find TvDB_FanArt image: {0}", fanart.FullImagePath);
return(null);
}
}
case JMMImageType.MovieDB_Poster:
MovieDB_Poster mPoster = repMoviePosters.GetByID(int.Parse(entityID));
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))
{
return(File.ReadAllBytes(mPoster.FullImagePath));
}
else
{
logger.Trace("Could not find MovieDB_Poster image: {0}", mPoster.FullImagePath);
return(null);
}
case JMMImageType.MovieDB_FanArt:
MovieDB_Fanart mFanart = repMovieFanart.GetByID(int.Parse(entityID));
if (mFanart == null)
{
return(null);
}
mFanart = repMovieFanart.GetByOnlineID(mFanart.URL);
if (mFanart == null)
{
return(null);
}
if (File.Exists(mFanart.FullImagePath))
{
return(File.ReadAllBytes(mFanart.FullImagePath));
}
else
{
logger.Trace("Could not find MovieDB_FanArt image: {0}", mFanart.FullImagePath);
return(null);
}
case JMMImageType.Trakt_Fanart:
Trakt_ImageFanart tFanart = repTraktFanart.GetByID(int.Parse(entityID));
if (tFanart == null)
{
return(null);
}
if (File.Exists(tFanart.FullImagePath))
{
return(File.ReadAllBytes(tFanart.FullImagePath));
}
else
{
logger.Trace("Could not find Trakt_Fanart image: {0}", tFanart.FullImagePath);
return(null);
}
case JMMImageType.Trakt_Friend:
Trakt_Friend tFriend = repTraktFriends.GetByID(int.Parse(entityID));
if (tFriend == null)
{
return(null);
}
if (File.Exists(tFriend.FullImagePath))
{
return(File.ReadAllBytes(tFriend.FullImagePath));
}
else
{
logger.Trace("Could not find Trakt_Friend image: {0}", tFriend.FullImagePath);
return(null);
}
case JMMImageType.Trakt_ActivityScrobble:
case JMMImageType.Trakt_ShoutUser:
Trakt_Friend tFriendScrobble = repTraktFriends.GetByID(int.Parse(entityID));
if (tFriendScrobble == null)
{
return(null);
}
if (File.Exists(tFriendScrobble.FullImagePath))
{
return(File.ReadAllBytes(tFriendScrobble.FullImagePath));
}
else
{
logger.Trace("Could not find Trakt_ActivityScrobble image: {0}", tFriendScrobble.FullImagePath);
return(null);
}
case JMMImageType.Trakt_Poster:
Trakt_ImagePoster tPoster = repTraktPosters.GetByID(int.Parse(entityID));
if (tPoster == null)
{
return(null);
}
if (File.Exists(tPoster.FullImagePath))
{
return(File.ReadAllBytes(tPoster.FullImagePath));
}
else
{
logger.Trace("Could not find Trakt_Poster image: {0}", tPoster.FullImagePath);
return(null);
}
case JMMImageType.Trakt_Episode:
case JMMImageType.Trakt_WatchedEpisode:
Trakt_Episode tEpisode = repTraktEpisodes.GetByID(int.Parse(entityID));
if (tEpisode == null)
{
return(null);
}
if (File.Exists(tEpisode.FullImagePath))
{
return(File.ReadAllBytes(tEpisode.FullImagePath));
}
else
{
logger.Trace("Could not find Trakt_Episode image: {0}", tEpisode.FullImagePath);
return(null);
}
default:
return(null);
}
}
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)
{
string msg = string.Format("Error deleting image: ({0}) - {1}", 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 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);
}
private AniDB_Anime SaveResultsForAnimeXML(ISession session, int animeID, bool downloadRelations,
AniDBHTTPCommand_GetFullAnime getAnimeCmd)
{
AniDB_Anime anime = null;
ISessionWrapper sessionWrapper = session.Wrap();
logger.Trace("cmdResult.Anime: {0}", getAnimeCmd.Anime);
anime = RepoFactory.AniDB_Anime.GetByAnimeID(sessionWrapper, animeID);
if (anime == null)
{
anime = new AniDB_Anime();
}
anime.PopulateAndSaveFromHTTP(session, getAnimeCmd.Anime, getAnimeCmd.Episodes, getAnimeCmd.Titles,
getAnimeCmd.Categories, getAnimeCmd.Tags,
getAnimeCmd.Characters, getAnimeCmd.Relations, getAnimeCmd.SimilarAnime, getAnimeCmd.Recommendations,
downloadRelations);
// Request an image download
CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(anime.AniDB_AnimeID,
JMMImageType.AniDB_Cover,
false);
cmd.Save(session);
// create AnimeEpisode records for all episodes in this anime
// only if we have a series
AnimeSeries ser = RepoFactory.AnimeSeries.GetByAnimeID(animeID);
RepoFactory.AniDB_Anime.Save(anime);
if (ser != null)
{
ser.CreateAnimeEpisodes(session);
RepoFactory.AnimeSeries.Save(ser, true, false);
}
// update any files, that may have been linked
/*CrossRef_File_EpisodeRepository repCrossRefs = new CrossRef_File_EpisodeRepository();
* repCrossRefs.GetByAnimeID(*/
// update cached stats
//StatsCache.Instance.UpdateUsingAnime(session, anime.AnimeID);
//StatsCache.Instance.UpdateAnimeContract(session, anime.AnimeID);
// download character images
foreach (AniDB_Anime_Character animeChar in anime.GetAnimeCharacters(session.Wrap()))
{
AniDB_Character chr = animeChar.GetCharacter(sessionWrapper);
if (chr == null)
{
continue;
}
if (ServerSettings.AniDB_DownloadCharacters)
{
if (!string.IsNullOrEmpty(chr.PosterPath) && !File.Exists(chr.PosterPath))
{
logger.Debug("Downloading character image: {0} - {1}({2}) - {3}", anime.MainTitle, chr.CharName,
chr.CharID,
chr.PosterPath);
cmd = new CommandRequest_DownloadImage(chr.AniDB_CharacterID, JMMImageType.AniDB_Character,
false);
cmd.Save();
}
}
if (ServerSettings.AniDB_DownloadCreators)
{
AniDB_Seiyuu seiyuu = chr.GetSeiyuu(session);
if (seiyuu == null || string.IsNullOrEmpty(seiyuu.PosterPath))
{
continue;
}
if (!File.Exists(seiyuu.PosterPath))
{
logger.Debug("Downloading seiyuu image: {0} - {1}({2}) - {3}", anime.MainTitle,
seiyuu.SeiyuuName, seiyuu.SeiyuuID,
seiyuu.PosterPath);
cmd = new CommandRequest_DownloadImage(seiyuu.AniDB_SeiyuuID, JMMImageType.AniDB_Creator, false);
cmd.Save();
}
}
}
return(anime);
}
public static string GetFileURL(ImageDownloadRequest req, bool thumbNailOnly)
{
switch (req.ImageType)
{
case JMMImageType.AniDB_Cover:
AniDB_Anime anime = req.ImageData as AniDB_Anime;
return(string.Format(Constants.URLS.AniDB_Images, anime.Picname));
case JMMImageType.TvDB_Episode:
TvDB_Episode ep = req.ImageData as TvDB_Episode;
return(string.Format(Constants.URLS.TvDB_Images, ep.Filename));
case JMMImageType.TvDB_FanArt:
TvDB_ImageFanart fanart = req.ImageData as TvDB_ImageFanart;
if (thumbNailOnly)
{
return(string.Format(Constants.URLS.TvDB_Images, fanart.ThumbnailPath));
}
else
{
return(string.Format(Constants.URLS.TvDB_Images, fanart.BannerPath));
}
case JMMImageType.TvDB_Cover:
TvDB_ImagePoster poster = req.ImageData as TvDB_ImagePoster;
return(string.Format(Constants.URLS.TvDB_Images, poster.BannerPath));
case JMMImageType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = req.ImageData as TvDB_ImageWideBanner;
return(string.Format(Constants.URLS.TvDB_Images, wideBanner.BannerPath));
case JMMImageType.MovieDB_Poster:
MovieDB_Poster moviePoster = req.ImageData as MovieDB_Poster;
return(moviePoster.URL);
case JMMImageType.MovieDB_FanArt:
MovieDB_Fanart movieFanart = req.ImageData as MovieDB_Fanart;
return(movieFanart.URL);
case JMMImageType.Trakt_Poster:
Trakt_ImagePoster traktPoster = req.ImageData as Trakt_ImagePoster;
return(traktPoster.ImageURL);
case JMMImageType.Trakt_Fanart:
Trakt_ImageFanart traktFanart = req.ImageData as Trakt_ImageFanart;
return(traktFanart.ImageURL);
case JMMImageType.Trakt_Friend:
Trakt_Friend traktFriend = req.ImageData as Trakt_Friend;
return(traktFriend.Avatar);
case JMMImageType.Trakt_Episode:
Trakt_Episode traktEp = req.ImageData as Trakt_Episode;
return(traktEp.EpisodeImage);
case JMMImageType.AniDB_Character:
AniDB_Character chr = req.ImageData as AniDB_Character;
return(string.Format(Constants.URLS.AniDB_Images, chr.PicName));
case JMMImageType.AniDB_Creator:
AniDB_Seiyuu creator = req.ImageData as AniDB_Seiyuu;
return(string.Format(Constants.URLS.AniDB_Images, creator.PicName));
default:
return("");
}
}
private static bool PopulateVideoEpisodeFromAnime(Video v, AnimeEpisode ep, AnimeSeries ser, Contract_AnimeSeries cserie, AniDB_Anime ani, Video nv)
{
bool ret = false;
// v.ParentTitle = "Season 1";
// v.GrandparentTitle = ser.GetSeriesName();
v.ParentIndex = "1";
v.Art = ani.GetDefaultFanartDetailsNoBlanks().GenArt();
if (ep.EpisodeTypeEnum != enEpisodeType.Episode)
{
//v.ParentTitle = ep.ToString();
v.ParentIndex = null;
}
else if (cserie.CrossRefAniDBTvDBV2 != null && cserie.CrossRefAniDBTvDBV2.Count > 0)
{
Contract_CrossRef_AniDB_TvDBV2 c2 =
cserie.CrossRefAniDBTvDBV2.FirstOrDefault(
a =>
a.AniDBStartEpisodeType == ep.AniDB_Episode.EpisodeType &&
a.AniDBStartEpisodeNumber <= ep.AniDB_Episode.EpisodeNumber);
if (c2 != null)
{
// v.ParentTitle = "Season " + c2.TvDBSeasonNumber;
if (c2.TvDBSeasonNumber > 0)
{
v.ParentIndex = c2.TvDBSeasonNumber.ToString();
}
}
}
//v.Title1 = v.GrandparentTitle;
//v.Title2 = v.ParentTitle;
if (ani != null)
{
if (ani.Restricted > 0)
{
v.ContentRating = "R";
}
if (ani.AnimeTypeEnum == enAnimeType.Movie)
{
v.Type = "movie";
if (v.Title.StartsWith("Complete Movie"))
{
v.Title = nv.Title;
v.Summary = nv.Summary;
v.Index = null;
ret = true;
}
else if (v.Title.StartsWith("Part "))
{
v.Title = nv.Title + " - " + v.Title;
v.Summary = nv.Summary;
}
v.Thumb = nv.Thumb;
}
else if (ani.AnimeTypeEnum == enAnimeType.OVA)
{
if (v.Title == "OVA")
{
v.Title = nv.Title;
v.Type = "movie";
v.Thumb = nv.Thumb;
v.Summary = nv.Summary;
v.Index = null;
ret = true;
}
}
// else
// v.ParentTitle = nv.Title;
}
if (string.IsNullOrEmpty(v.Art))
{
v.Art = nv.Art;
}
if (v.Tags == null)
{
v.Tags = nv.Tags;
}
if (v.Genres == null)
{
v.Genres = nv.Genres;
}
if (v.Roles == null)
{
v.Roles = nv.Roles;
}
if (string.IsNullOrEmpty(v.Rating))
{
v.Rating = nv.Rating;
}
v.Index = ep.AniDB_Episode.EpisodeNumber.ToString();
return(ret);
}
public static Video MayReplaceVideo(Video v1, AnimeSeries ser, Contract_AnimeSeries cserie, AniDB_Anime anime, JMMType type, int userid, bool all = true)
{
int epcount = all ? ser.GetAnimeEpisodesCountWithVideoLocal() : ser.GetAnimeEpisodesNormalCountWithVideoLocal();
if ((epcount == 1) && (anime.AnimeTypeEnum == enAnimeType.OVA || anime.AnimeTypeEnum == enAnimeType.Movie))
{
List <AnimeEpisode> episodes = ser.GetAnimeEpisodes();
List <VideoLocal> l = episodes[0].GetVideoLocals();
if (l.Count > 0)
{
Video v2 = new Video();
try
{
if (PopulateVideo(v2, l[0], episodes[0], ser, cserie, anime, v1, JMMType.File, userid))
{
v2.Thumb = anime.GetDefaultPosterDetailsNoBlanks().GenPoster();
return(v2);
}
}
catch (Exception e)
{
//Fast fix if file do not exist, and still is in db. (Xml Serialization of video info will fail on null)
}
}
}
return(v1);
}
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_GetCalendar");
try
{
// we will always assume that an anime was downloaded via http first
ScheduledUpdate sched = RepoFactory.ScheduledUpdate.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;
RepoFactory.ScheduledUpdate.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 = RepoFactory.AniDB_Anime.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;
RepoFactory.AniDB_Anime.Save(anime);
AnimeSeries ser = RepoFactory.AnimeSeries.GetByAnimeID(anime.AnimeID);
if (ser != null)
{
RepoFactory.AnimeSeries.Save(ser, true, false);
}
}
}
}
else
{
CommandRequest_GetAnimeHTTP cmdAnime = new CommandRequest_GetAnimeHTTP(cal.AnimeID, true, false);
cmdAnime.Save();
}
}
}
catch (Exception ex)
{
logger.Error(ex, "Error processing CommandRequest_GetCalendar: " + ex.ToString());
return;
}
}
public System.IO.Stream GetItemsFromSerie(int userid, string SerieId, HistoryInfo info)
{
PlexObject ret = null;
enEpisodeType?eptype = null;
int serieID;
if (SerieId.Contains("_"))
{
int ept;
string[] ndata = SerieId.Split('_');
if (!int.TryParse(ndata[0], out ept))
{
return(new MemoryStream());
}
eptype = (enEpisodeType)ept;
if (!int.TryParse(ndata[1], out serieID))
{
return(new MemoryStream());
}
}
else
{
if (!int.TryParse(SerieId, out serieID))
{
return(new MemoryStream());
}
}
using (var session = JMMService.SessionFactory.OpenSession())
{
if (serieID == -1)
{
return(new MemoryStream());
}
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries ser = repSeries.GetByID(session, serieID);
if (ser == null)
{
return(new MemoryStream());
}
AniDB_Anime anime = ser.GetAnime();
if (anime == null)
{
return(new MemoryStream());
}
Contract_AnimeSeries cseries = ser.ToContract(ser.GetUserRecord(userid), true);
ImageDetails fanart = anime.GetDefaultFanartDetailsNoBlanks(session);
//iOS Hack, since it uses the previous thumb, as overlay image on the episodes
bool iosHack = false;
if (WebOperationContext.Current != null && WebOperationContext.Current.IncomingRequest.Headers.AllKeys.Contains("X-Plex-Product"))
{
string kh = WebOperationContext.Current.IncomingRequest.Headers.Get("X-Plex-Product").ToUpper();
if (kh.Contains(" IOS"))
{
iosHack = true;
}
}
List <AnimeEpisode> episodes = ser.GetAnimeEpisodes(session).Where(a => a.GetVideoLocals(session).Count > 0).ToList();
if (eptype.HasValue)
{
ret = new PlexObject(PlexHelper.NewMediaContainer(MediaContainerTypes.Episode, info, true));
if (!ret.Init())
{
return(new MemoryStream());
}
ret.MediaContainer.LeafCount = (cseries.WatchedEpisodeCount + cseries.UnwatchedEpisodeCount).ToString();
ret.MediaContainer.ViewedLeafCount = cseries.WatchedEpisodeCount.ToString();
episodes = episodes.Where(a => a.EpisodeTypeEnum == eptype.Value).ToList();
}
else
{
ret = new PlexObject(PlexHelper.NewMediaContainer(MediaContainerTypes.Show, info, true));
if (!ret.Init())
{
return(new MemoryStream());
}
ret.MediaContainer.LeafCount = (cseries.WatchedEpisodeCount + cseries.UnwatchedEpisodeCount).ToString();
ret.MediaContainer.ViewedLeafCount = cseries.WatchedEpisodeCount.ToString();
List <enEpisodeType> types = episodes.Select(a => a.EpisodeTypeEnum).Distinct().ToList();
if (types.Count > 1)
{
List <PlexEpisodeType> eps = new List <PlexEpisodeType>();
foreach (enEpisodeType ee in types)
{
PlexEpisodeType k2 = new PlexEpisodeType();
PlexEpisodeType.EpisodeTypeTranslated(k2, ee, (AnimeTypes)anime.AnimeType, episodes.Count(a => a.EpisodeTypeEnum == ee));
eps.Add(k2);
}
List <SortPropOrFieldAndDirection> sortCriteria = new List <SortPropOrFieldAndDirection>();
sortCriteria.Add(new SortPropOrFieldAndDirection("Name", SortType.eString));
eps = Sorting.MultiSort(eps, sortCriteria);
List <Video> dirs = new List <Video>();
bool converttoseason = true;
foreach (PlexEpisodeType ee in eps)
{
Video v = new Directory();
if (fanart != null)
{
v.Art = fanart.GenArt();
}
v.Title = ee.Name;
v.LeafCount = ee.Count.ToString();
v.ChildCount = v.LeafCount;
v.ViewedLeafCount = "0";
v.Key = PlexHelper.ConstructSerieIdUrl(userid, ee.Type + "_" + ser.AnimeSeriesID);
v.Thumb = PlexHelper.ConstructSupportImageLink(ee.Image);
if ((ee.AnimeType == AnimeTypes.Movie) || (ee.AnimeType == AnimeTypes.OVA))
{
v = PlexHelper.MayReplaceVideo(v, ser, cseries, anime, JMMType.File, userid, false);
}
dirs.Add(v, info);
if (iosHack)
{
v.Thumb = ret.MediaContainer.ParentThumb;
v.ParentThumb = ret.MediaContainer.GrandparentThumb;
v.GrandparentThumb = ret.MediaContainer.GrandparentThumb;
v.ParentKey = v.GrandparentKey;
}
}
ret.Childrens = dirs;
return(ret.GetStream());
}
}
List <Video> vids = new List <Video>();
Video nv = new Video();
PlexHelper.FillSerie(nv, ser, anime, cseries, userid);
foreach (AnimeEpisode ep in episodes)
{
Video v = new Video();
List <VideoLocal> locals = ep.GetVideoLocals(session);
if ((locals == null) || (locals.Count == 0))
{
continue;
}
AniDB_Episode aep = ep.AniDB_Episode;
if (aep == null)
{
continue;
}
VideoLocal current = locals[0];
try
{
PlexHelper.PopulateVideo(v, current, ep, ser, cseries, anime, nv, JMMType.File, userid);
vids.Add(v, info);
if (iosHack)
{
v.Art = v.Thumb;
v.Thumb = ret.MediaContainer.ParentThumb;
}
}
catch (Exception e)
{
//Fast fix if file do not exist, and still is in db. (Xml Serialization of video info will fail on null)
}
}
List <SortPropOrFieldAndDirection> sortCriteria2 = new List <SortPropOrFieldAndDirection>();
sortCriteria2.Add(new SortPropOrFieldAndDirection("EpNumber", SortType.eInteger));
vids = Sorting.MultiSort(vids, sortCriteria2);
ret.Childrens = vids;
return(ret.GetStream());
}
}
public void VoteAnime(string userid, string seriesid, string votevalue, string votetype)
{
int serid = 0;
int usid = 0;
int vt = 0;
double vvalue = 0;
if (!int.TryParse(seriesid, out serid))
{
return;
}
if (!int.TryParse(userid, out usid))
{
return;
}
if (!int.TryParse(votetype, out vt))
{
return;
}
if (!double.TryParse(votevalue, NumberStyles.Any, CultureInfo.InvariantCulture, out vvalue))
{
return;
}
using (var session = JMMService.SessionFactory.OpenSession())
{
AnimeSeriesRepository repSeries = new AnimeSeriesRepository();
AnimeSeries ser = repSeries.GetByID(session, serid);
AniDB_Anime anime = ser.GetAnime();
if (anime == null)
{
return;
}
string msg = string.Format("Voting for anime: {0} - Value: {1}", anime.AnimeID, vvalue);
logger.Info(msg);
// lets save to the database and assume it will work
AniDB_VoteRepository repVotes = new AniDB_VoteRepository();
List <AniDB_Vote> dbVotes = repVotes.GetByEntity(anime.AnimeID);
AniDB_Vote thisVote = null;
foreach (AniDB_Vote dbVote in dbVotes)
{
// we can only have anime permanent or anime temp but not both
if (vt == (int)enAniDBVoteType.Anime || vt == (int)enAniDBVoteType.AnimeTemp)
{
if (dbVote.VoteType == (int)enAniDBVoteType.Anime ||
dbVote.VoteType == (int)enAniDBVoteType.AnimeTemp)
{
thisVote = dbVote;
}
}
else
{
thisVote = dbVote;
}
}
if (thisVote == null)
{
thisVote = new AniDB_Vote();
thisVote.EntityID = anime.AnimeID;
}
thisVote.VoteType = vt;
int iVoteValue = 0;
if (vvalue > 0)
{
iVoteValue = (int)(vvalue * 100);
}
else
{
iVoteValue = (int)vvalue;
}
msg = string.Format("Voting for anime Formatted: {0} - Value: {1}", anime.AnimeID, iVoteValue);
logger.Info(msg);
thisVote.VoteValue = iVoteValue;
repVotes.Save(thisVote);
CommandRequest_VoteAnime cmdVote = new CommandRequest_VoteAnime(anime.AnimeID, vt, Convert.ToDecimal(vvalue));
cmdVote.Save();
}
}
public System.IO.Stream GetFilters(string uid)
{
int t = 0;
int.TryParse(uid, out t);
JMMUser user = t > 0 ? PlexHelper.GetJMMUser(uid) : PlexHelper.GetUser(uid);
if (user == null)
{
return(new MemoryStream());
}
int userid = user.JMMUserID;
HistoryInfo info = new HistoryInfo {
Key = PlexHelper.ConstructFiltersUrl(userid), Title = "Anime"
};
PlexObject ret = new PlexObject(PlexHelper.NewMediaContainer(MediaContainerTypes.Show, info, false));
if (!ret.Init())
{
return(new MemoryStream());
}
List <Video> dirs = new List <Video>();
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
GroupFilterRepository repGF = new GroupFilterRepository();
List <GroupFilter> allGfs = repGF.GetAll(session);
Dictionary <int, HashSet <int> > gstats = StatsCache.Instance.StatUserGroupFilter[userid];
foreach (GroupFilter gg in allGfs.ToArray())
{
if ((!StatsCache.Instance.StatUserGroupFilter.ContainsKey(userid)) ||
(!StatsCache.Instance.StatUserGroupFilter[userid].ContainsKey(gg.GroupFilterID)))
{
allGfs.Remove(gg);
}
}
AnimeGroupRepository repGroups = new AnimeGroupRepository();
allGfs.Insert(0, new GroupFilter()
{
GroupFilterName = "All", GroupFilterID = -999
});
foreach (GroupFilter gg in allGfs)
{
Random rnd = new Random(123456789);
Directory pp = new Directory {
Type = "show"
};
pp.Key = PlexHelper.ConstructFilterIdUrl(userid, gg.GroupFilterID);
pp.Title = gg.GroupFilterName;
HashSet <int> groups;
groups = gg.GroupFilterID == -999 ? new HashSet <int>(repGroups.GetAllTopLevelGroups(session).Select(a => a.AnimeGroupID)) : gstats[gg.GroupFilterID];
if (groups.Count != 0)
{
bool repeat;
int nn = 0;
pp.LeafCount = groups.Count.ToString();
pp.ViewedLeafCount = "0";
do
{
repeat = true;
int grp = groups.ElementAt(rnd.Next(groups.Count));
AnimeGroup ag = repGroups.GetByID(grp);
List <AnimeSeries> sers = ag.GetSeries(session);
if (sers.Count > 0)
{
AnimeSeries ser = sers[rnd.Next(sers.Count)];
AniDB_Anime anim = ser.GetAnime(session);
if (anim != null)
{
ImageDetails poster = anim.GetDefaultPosterDetailsNoBlanks(session);
ImageDetails fanart = anim.GetDefaultFanartDetailsNoBlanks(session);
if (poster != null)
{
pp.Thumb = poster.GenPoster();
}
if (fanart != null)
{
pp.Art = fanart.GenArt();
}
if (poster != null)
{
repeat = false;
}
}
}
nn++;
if ((repeat) && (nn == 15))
{
repeat = false;
}
} while (repeat);
dirs.Add(pp, info);
}
}
VideoLocalRepository repVids = new VideoLocalRepository();
List <VideoLocal> vids = repVids.GetVideosWithoutEpisode();
if (vids.Count > 0)
{
Directory pp = new Directory()
{
Type = "show"
};
pp.Key = PlexHelper.ConstructUnsortUrl(userid);
pp.Title = "Unsort";
pp.Thumb = PlexHelper.ConstructSupportImageLink("plex_unsort.png");
pp.LeafCount = vids.Count.ToString();
pp.ViewedLeafCount = "0";
dirs.Add(pp, info);
}
var repPlaylist = new PlaylistRepository();
var playlists = repPlaylist.GetAll();
if (playlists.Count > 0)
{
Directory pp = new Directory()
{
Type = "show"
};
pp.Key = PlexHelper.ConstructPlaylistUrl(userid);
pp.Title = "Playlists";
pp.Thumb = PlexHelper.ConstructSupportImageLink("plex_playlists.png");
pp.LeafCount = playlists.Count.ToString();
pp.ViewedLeafCount = "0";
dirs.Add(pp, info);
}
dirs = dirs.OrderBy(a => a.Title).ToList();
}
ret.Childrens = dirs;
return(ret.GetStream());
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return(new MemoryStream());
}
}
private void ProcessFile_AniDB(VideoLocal vidLocal)
{
logger.Trace("Checking for AniDB_File record for: {0} --- {1}", vidLocal.Hash, vidLocal.FileName);
// check if we already have this AniDB_File info in the database
AniDB_File aniFile = null;
if (!ForceAniDB)
{
aniFile = RepoFactory.AniDB_File.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 = RepoFactory.AniDB_File.GetByHashAndFileSize(vidLocal.Hash, vlocal.FileSize);
if (aniFile == null)
{
aniFile = new AniDB_File();
}
aniFile.Populate(fileInfo);
//overwrite with local file name
string localFileName = vidLocal.FileName;
aniFile.FileName = localFileName;
RepoFactory.AniDB_File.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 = RepoFactory.CrossRef_File_Episode.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 = vidLocal.FileName;
xrefEnt.FileSize = vidLocal.FileSize;
xrefEnt.CrossRefSource = (int)JMMServer.CrossRefSource.WebCache;
xrefEnt.AnimeID = xref.AnimeID;
xrefEnt.EpisodeID = xref.EpisodeID;
xrefEnt.Percentage = xref.Percentage;
xrefEnt.EpisodeOrder = xref.EpisodeOrder;
bool duplicate = false;
foreach (CrossRef_File_Episode xrefcheck in crossRefs)
{
if (xrefcheck.AnimeID == xrefEnt.AnimeID &&
xrefcheck.EpisodeID == xrefEnt.EpisodeID &&
xrefcheck.Hash == xrefEnt.Hash)
{
duplicate = true;
}
}
if (!duplicate)
{
crossRefs.Add(xrefEnt);
// in this case we need to save the cross refs manually as AniDB did not provide them
RepoFactory.CrossRef_File_Episode.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 = RepoFactory.AniDB_Episode.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 = RepoFactory.AniDB_Episode.GetByEpisodeID(xref.EpisodeID);
if (ep == null)
{
missingEpisodes = true;
}
animeID = xref.AnimeID;
}
}
}
// get from DB
AniDB_Anime anime = RepoFactory.AniDB_Anime.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 = RepoFactory.AnimeSeries.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
if (RepoFactory.AniDB_GroupStatus.GetByAnimeID(anime.AnimeID).Count == 0)
{
CommandRequest_GetReleaseGroupStatus cmdStatus =
new CommandRequest_GetReleaseGroupStatus(anime.AnimeID, false);
cmdStatus.Save();
}
// update stats
ser.EpisodeAddedDate = DateTime.Now;
RepoFactory.AnimeSeries.Save(ser, false, false);
foreach (AnimeGroup grp in ser.AllGroupsAbove)
{
grp.EpisodeAddedDate = DateTime.Now;
RepoFactory.AnimeGroup.Save(grp, true, false);
}
}
vidLocal.Places.ForEach(a =>
{
a.RenameIfRequired();
a.MoveFileIfRequired();
});
// update stats for groups and series
if (ser != null)
{
// update all the groups above this series in the heirarchy
ser.QueueUpdateStats();
//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();
}
}
public static Video FromSerieWithPossibleReplacement(Contract_AnimeSeries cserie, AnimeSeries ser, AniDB_Anime anidb, int userid)
{
Video v = new Directory();
FillSerie(v, ser, anidb, cserie, userid);
if (ser.GetAnimeNumberOfEpisodeTypes() > 1)
{
v.Type = "show";
}
else if ((cserie.AniDBAnime.AnimeType == (int)enAnimeType.Movie) || (cserie.AniDBAnime.AnimeType == (int)enAnimeType.OVA))
{
v = MayReplaceVideo(v, ser, cserie, ser.GetAnime(), JMMType.File, userid);
}
return(v);
}
public AniDB_Anime GetAnimeInfoUDP(int animeID, bool forceRefresh)
{
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = null;
bool skip = true;
if (forceRefresh)
{
skip = false;
}
else
{
anime = repAnime.GetByAnimeID(animeID);
if (anime == null)
{
skip = false;
}
}
if (skip)
{
if (anime == null)
{
anime = repAnime.GetByAnimeID(animeID);
}
return(anime);
}
if (!Login())
{
return(null);
}
enHelperActivityType ev = enHelperActivityType.NoSuchAnime;
AniDBCommand_GetAnimeInfo getAnimeCmd = null;
lock (lockAniDBConnections)
{
Pause();
getAnimeCmd = new AniDBCommand_GetAnimeInfo();
getAnimeCmd.Init(animeID, forceRefresh);
SetWaitingOnResponse(true);
ev = getAnimeCmd.Process(ref soUdp, ref remoteIpEndPoint, curSessionID, new UnicodeEncoding(true, false));
SetWaitingOnResponse(false);
}
if (ev == enHelperActivityType.GotAnimeInfo && getAnimeCmd.AnimeInfo != null)
{
// check for an existing record so we don't over write the description
anime = repAnime.GetByAnimeID(getAnimeCmd.AnimeInfo.AnimeID);
if (anime == null)
{
anime = new AniDB_Anime();
}
anime.PopulateAndSaveFromUDP(getAnimeCmd.AnimeInfo);
}
return(anime);
}
public static void FillSerie(Video p, AnimeSeries aser, AniDB_Anime anidb, Contract_AnimeSeries ser, int userid)
{
using (ISession session = JMMService.SessionFactory.OpenSession())
{
Contract_AniDBAnime anime = ser.AniDBAnime;
p.Key = ConstructSerieIdUrl(userid, ser.AnimeSeriesID.ToString());
if (ser.AniDBAnime.Restricted > 0)
{
p.ContentRating = "R";
}
p.Title = aser.GetSeriesName(session);
p.Summary = SummaryFromAnimeContract(ser);
p.Type = "show";
p.AirDate = DateTime.MinValue;
TextInfo textInfo = new CultureInfo("en-US", false).TextInfo;
if (!string.IsNullOrEmpty(anime.AllTags))
{
p.Genres = new List <Tag>();
anime.AllTags.Split('|').ToList().ForEach(a => p.Genres.Add(new Tag {
Value = textInfo.ToTitleCase(a.Trim())
}));
}
//p.OriginalTitle
if (anime.AirDate.HasValue)
{
p.AirDate = anime.AirDate.Value;
p.OriginallyAvailableAt = anime.AirDate.Value.ToPlexDate();
p.Year = anime.AirDate.Value.Year.ToString();
}
p.LeafCount = anime.EpisodeCount.ToString();
//p.ChildCount = p.LeafCount;
p.ViewedLeafCount = ser.WatchedEpisodeCount.ToString();
p.Rating = (anime.Rating / 100F).ToString(CultureInfo.InvariantCulture);
List <Contract_CrossRef_AniDB_TvDBV2> ls = ser.CrossRefAniDBTvDBV2;
if (ls != null && ls.Count > 0)
{
foreach (Contract_CrossRef_AniDB_TvDBV2 c in ls)
{
if (c.TvDBSeasonNumber != 0)
{
p.Season = c.TvDBSeasonNumber.ToString();
p.Index = p.Season;
}
}
}
p.Thumb = anime.DefaultImagePoster.GenPoster();
p.Art = anime.DefaultImageFanart.GenArt();
List <AniDB_Anime_Character> chars = anidb.GetAnimeCharacters(session);
p.Roles = new List <Tag>();
if (chars != null)
{
foreach (AniDB_Anime_Character c in chars)
{
AniDB_Character cha = c.GetCharacter(session);
AniDB_Seiyuu seiyuu = cha?.GetSeiyuu(session);
if (seiyuu != null)
{
p.Roles.Add(new Tag
{
Value = seiyuu.SeiyuuName,
Role = cha.CharName
});
}
}
}
}
}
public GroupStatusCollection GetReleaseGroupStatusUDP(int animeID)
{
if (!Login())
{
return(null);
}
enHelperActivityType ev = enHelperActivityType.NoSuchCreator;
AniDBCommand_GetGroupStatus getCmd = null;
lock (lockAniDBConnections)
{
getCmd = new AniDBCommand_GetGroupStatus();
getCmd.Init(animeID);
SetWaitingOnResponse(true);
ev = getCmd.Process(ref soUdp, ref remoteIpEndPoint, curSessionID, new UnicodeEncoding(true, false));
SetWaitingOnResponse(false);
}
if (ev == enHelperActivityType.GotGroupStatus && getCmd.GrpStatusCollection != null)
{
// delete existing records
RepoFactory.AniDB_GroupStatus.DeleteForAnime(animeID);
// save the records
foreach (Raw_AniDB_GroupStatus raw in getCmd.GrpStatusCollection.Groups)
{
AniDB_GroupStatus grpstat = new AniDB_GroupStatus(raw);
RepoFactory.AniDB_GroupStatus.Save(grpstat);
}
// updated cached stats
// we don't do it in the save method as it would be too many unecessary updates
logger.Trace("Updating group stats by anime from GetReleaseGroupStatusUDP: {0}", animeID);
// StatsCache.Instance.UpdateUsingAnime(animeID);
//Removed QueueUpdateStatus will Update Groups
if (getCmd.GrpStatusCollection.LatestEpisodeNumber > 0)
{
// update the anime with a record of the latest subbed episode
AniDB_Anime anime = RepoFactory.AniDB_Anime.GetByAnimeID(animeID);
if (anime != null)
{
anime.LatestEpisodeNumber = getCmd.GrpStatusCollection.LatestEpisodeNumber;
RepoFactory.AniDB_Anime.Save(anime);
// check if we have this episode in the database
// if not get it now by updating the anime record
List <AniDB_Episode> eps = RepoFactory.AniDB_Episode.GetByAnimeIDAndEpisodeNumber(animeID,
getCmd.GrpStatusCollection.LatestEpisodeNumber);
if (eps.Count == 0)
{
CommandRequest_GetAnimeHTTP cr_anime = new CommandRequest_GetAnimeHTTP(animeID, true, false);
cr_anime.Save();
}
// update the missing episode stats on groups and children
AnimeSeries series = RepoFactory.AnimeSeries.GetByAnimeID(animeID);
if (series != null)
{
series.QueueUpdateStats();
//series.TopLevelAnimeGroup.UpdateStatsFromTopLevel(true, true, true);
}
}
}
}
return(getCmd.GrpStatusCollection);
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_MovieDBSearchAnime: {0}", AnimeID);
try
{
using (var session = DatabaseFactory.SessionFactory.OpenSession())
{
ISessionWrapper sessionWrapper = session.Wrap();
// first check if the user wants to use the web cache
if (ServerSettings.WebCache_TvDB_Get)
{
try
{
JMMServer.Providers.Azure.CrossRef_AniDB_Other crossRef =
JMMServer.Providers.Azure.AzureWebAPI.Get_CrossRefAniDBOther(AnimeID,
CrossRefType.MovieDB);
if (crossRef != null)
{
int movieID = int.Parse(crossRef.CrossRefID);
MovieDB_Movie movie = RepoFactory.MovieDb_Movie.GetByOnlineID(sessionWrapper, movieID);
if (movie == null)
{
// update the info from online
MovieDBHelper.UpdateMovieInfo(session, movieID, true);
movie = RepoFactory.MovieDb_Movie.GetByOnlineID(movieID);
}
if (movie != null)
{
// since we are using the web cache result, let's save it
MovieDBHelper.LinkAniDBMovieDB(AnimeID, movieID, true);
return;
}
}
}
catch (Exception)
{
}
}
string searchCriteria = "";
AniDB_Anime anime = RepoFactory.AniDB_Anime.GetByAnimeID(sessionWrapper, 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 <MovieDB_Movie_Result> results = MovieDBHelper.Search(searchCriteria);
logger.Trace("Found {0} moviedb results for {1} on TheTvDB", results.Count, searchCriteria);
if (ProcessSearchResults(session, results, searchCriteria))
{
return;
}
if (results.Count == 0)
{
foreach (AniDB_Anime_Title title in anime.GetTitles())
{
if (title.TitleType.ToUpper() != Constants.AnimeTitleType.Official.ToUpper())
{
continue;
}
if (searchCriteria.ToUpper() == title.Title.ToUpper())
{
continue;
}
results = MovieDBHelper.Search(title.Title);
logger.Trace("Found {0} moviedb 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;
}
}
private string GetFileName(ImageDownloadRequest req, bool thumbNailOnly)
{
switch (req.ImageType)
{
case JMMImageType.AniDB_Cover:
AniDB_Anime anime = req.ImageData as AniDB_Anime;
return(anime.PosterPath);
case JMMImageType.TvDB_Episode:
TvDB_Episode ep = req.ImageData as TvDB_Episode;
return(ep.FullImagePath);
case JMMImageType.TvDB_FanArt:
TvDB_ImageFanart fanart = req.ImageData as TvDB_ImageFanart;
if (thumbNailOnly)
{
return(fanart.FullThumbnailPath);
}
else
{
return(fanart.FullImagePath);
}
case JMMImageType.TvDB_Cover:
TvDB_ImagePoster poster = req.ImageData as TvDB_ImagePoster;
return(poster.FullImagePath);
case JMMImageType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = req.ImageData as TvDB_ImageWideBanner;
return(wideBanner.FullImagePath);
case JMMImageType.MovieDB_Poster:
MovieDB_Poster moviePoster = req.ImageData as MovieDB_Poster;
return(moviePoster.FullImagePath);
case JMMImageType.MovieDB_FanArt:
MovieDB_Fanart movieFanart = req.ImageData as MovieDB_Fanart;
return(movieFanart.FullImagePath);
case JMMImageType.Trakt_Poster:
Trakt_ImagePoster traktPoster = req.ImageData as Trakt_ImagePoster;
return(traktPoster.FullImagePath);
case JMMImageType.Trakt_Fanart:
Trakt_ImageFanart traktFanart = req.ImageData as Trakt_ImageFanart;
return(traktFanart.FullImagePath);
case JMMImageType.Trakt_Friend:
Trakt_Friend traktFriend = req.ImageData as Trakt_Friend;
return(traktFriend.FullImagePath);
case JMMImageType.Trakt_Episode:
Trakt_Episode traktEp = req.ImageData as Trakt_Episode;
return(traktEp.FullImagePath);
case JMMImageType.AniDB_Character:
AniDB_Character chr = req.ImageData as AniDB_Character;
return(chr.PosterPath);
case JMMImageType.AniDB_Creator:
AniDB_Seiyuu creator = req.ImageData as AniDB_Seiyuu;
return(creator.PosterPath);
default:
return("");
}
}
public static void MigrateTraktLinks_V1_to_V2()
{
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
List <CrossRef_AniDB_Trakt> xrefsTrakt = RepoFactory.CrossRef_AniDB_Trakt.GetAll();
foreach (CrossRef_AniDB_Trakt xrefTrakt in xrefsTrakt)
{
CrossRef_AniDB_TraktV2 xrefNew = new CrossRef_AniDB_TraktV2();
xrefNew.AnimeID = xrefTrakt.AnimeID;
xrefNew.CrossRefSource = xrefTrakt.CrossRefSource;
xrefNew.TraktID = xrefTrakt.TraktID;
xrefNew.TraktSeasonNumber = xrefTrakt.TraktSeasonNumber;
Trakt_Show show = xrefTrakt.GetByTraktShow(session);
if (show != null)
{
xrefNew.TraktTitle = show.Title;
}
// determine start ep type
if (xrefTrakt.TraktSeasonNumber == 0)
{
xrefNew.AniDBStartEpisodeType = (int)enEpisodeType.Special;
}
else
{
xrefNew.AniDBStartEpisodeType = (int)enEpisodeType.Episode;
}
xrefNew.AniDBStartEpisodeNumber = 1;
xrefNew.TraktStartEpisodeNumber = 1;
RepoFactory.CrossRef_AniDB_TraktV2.Save(xrefNew);
}
// create cross ref's for specials
foreach (CrossRef_AniDB_Trakt xrefTrakt in xrefsTrakt)
{
AniDB_Anime anime = RepoFactory.AniDB_Anime.GetByAnimeID(xrefTrakt.AnimeID);
if (anime == null)
{
continue;
}
Trakt_Show show = xrefTrakt.GetByTraktShow(session);
if (show == null)
{
continue;
}
// this anime has specials
if (anime.EpisodeCountSpecial <= 0)
{
continue;
}
// this Trakt series has a season 0 (specials)
List <int> seasons = RepoFactory.Trakt_Episode.GetSeasonNumbersForSeries(show.Trakt_ShowID);
if (!seasons.Contains(0))
{
continue;
}
//make sure we are not doubling up
CrossRef_AniDB_TraktV2 temp = RepoFactory.CrossRef_AniDB_TraktV2.GetByTraktID(xrefTrakt.TraktID, 0, 1,
xrefTrakt.AnimeID,
(int)enEpisodeType.Special, 1);
if (temp != null)
{
continue;
}
CrossRef_AniDB_TraktV2 xrefNew = new CrossRef_AniDB_TraktV2();
xrefNew.AnimeID = xrefTrakt.AnimeID;
xrefNew.CrossRefSource = xrefTrakt.CrossRefSource;
xrefNew.TraktID = xrefTrakt.TraktID;
xrefNew.TraktSeasonNumber = 0;
xrefNew.TraktStartEpisodeNumber = 1;
xrefNew.AniDBStartEpisodeType = (int)enEpisodeType.Special;
xrefNew.AniDBStartEpisodeNumber = 1;
xrefNew.TraktTitle = show.Title;
RepoFactory.CrossRef_AniDB_TraktV2.Save(xrefNew);
}
}
}
catch (Exception ex)
{
logger.Error(ex, "Could not MigrateTraktLinks_V1_to_V2: " + ex.ToString());
}
}
public Contract_AnimeSeries ToContract(AniDB_Anime animeRec, List <CrossRef_AniDB_TvDBV2> tvDBCrossRefs, CrossRef_AniDB_Other movieDBCrossRef,
AnimeSeries_User userRecord, List <TvDB_Series> tvseries, List <CrossRef_AniDB_MAL> malDBCrossRef, bool passedDefaultImages, AniDB_Anime_DefaultImage defPoster,
AniDB_Anime_DefaultImage defFanart, AniDB_Anime_DefaultImage defWideBanner, List <AniDB_Anime_Title> titles, bool forceimages = false)
{
Contract_AnimeSeries contract = new Contract_AnimeSeries();
contract.AniDB_ID = this.AniDB_ID;
contract.AnimeGroupID = this.AnimeGroupID;
contract.AnimeSeriesID = this.AnimeSeriesID;
contract.DateTimeUpdated = this.DateTimeUpdated;
contract.DateTimeCreated = this.DateTimeCreated;
contract.DefaultAudioLanguage = this.DefaultAudioLanguage;
contract.DefaultSubtitleLanguage = this.DefaultSubtitleLanguage;
contract.LatestLocalEpisodeNumber = this.LatestLocalEpisodeNumber;
contract.EpisodeAddedDate = this.EpisodeAddedDate;
contract.MissingEpisodeCount = this.MissingEpisodeCount;
contract.MissingEpisodeCountGroups = this.MissingEpisodeCountGroups;
contract.SeriesNameOverride = this.SeriesNameOverride;
if (userRecord == null)
{
contract.PlayedCount = 0;
contract.StoppedCount = 0;
contract.UnwatchedEpisodeCount = 0;
contract.WatchedCount = 0;
contract.WatchedDate = null;
contract.WatchedEpisodeCount = 0;
}
else
{
contract.PlayedCount = userRecord.PlayedCount;
contract.StoppedCount = userRecord.StoppedCount;
contract.UnwatchedEpisodeCount = userRecord.UnwatchedEpisodeCount;
contract.WatchedCount = userRecord.WatchedCount;
contract.WatchedDate = userRecord.WatchedDate;
contract.WatchedEpisodeCount = userRecord.WatchedEpisodeCount;
}
// get AniDB data
contract.AniDBAnime = null;
if (animeRec != null)
{
Contract_AniDBAnime animecontract = animeRec.ToContract(false, titles);
AniDB_Anime_DefaultImage defaultPoster = null;
if (passedDefaultImages)
{
defaultPoster = defPoster;
}
else
{
defaultPoster = animeRec.GetDefaultPoster();
}
if (defaultPoster == null)
{
animecontract.DefaultImagePoster = null;
}
else
{
animecontract.DefaultImagePoster = defaultPoster.ToContract();
}
if ((animecontract.DefaultImagePoster == null) && (forceimages))
{
ImageDetails im = animeRec.GetDefaultPosterDetailsNoBlanks();
if (im != null)
{
animecontract.DefaultImagePoster = new Contract_AniDB_Anime_DefaultImage();
animecontract.DefaultImagePoster.AnimeID = im.ImageID;
animecontract.DefaultImagePoster.ImageType = (int)im.ImageType;
}
}
AniDB_Anime_DefaultImage defaultFanart = null;
if (passedDefaultImages)
{
defaultFanart = defFanart;
}
else
{
defaultFanart = animeRec.GetDefaultFanart();
}
if (defaultFanart == null)
{
animecontract.DefaultImageFanart = null;
}
else
{
animecontract.DefaultImageFanart = defaultFanart.ToContract();
}
if ((animecontract.DefaultImagePoster == null) && (forceimages))
{
ImageDetails im = animeRec.GetDefaultFanartDetailsNoBlanks();
if (im != null)
{
animecontract.DefaultImageFanart = new Contract_AniDB_Anime_DefaultImage();
animecontract.DefaultImageFanart.AnimeID = im.ImageID;
animecontract.DefaultImageFanart.ImageType = (int)im.ImageType;
}
}
AniDB_Anime_DefaultImage defaultWideBanner = null;
if (passedDefaultImages)
{
defaultWideBanner = defWideBanner;
}
else
{
defaultWideBanner = animeRec.GetDefaultWideBanner();
}
if (defaultWideBanner == null)
{
animecontract.DefaultImageWideBanner = null;
}
else
{
animecontract.DefaultImageWideBanner = defaultWideBanner.ToContract();
}
contract.AniDBAnime = animecontract;
}
contract.CrossRefAniDBTvDBV2 = new List <Contract_CrossRef_AniDB_TvDBV2>();
foreach (CrossRef_AniDB_TvDBV2 tvXref in tvDBCrossRefs)
{
contract.CrossRefAniDBTvDBV2.Add(tvXref.ToContract());
}
contract.TvDB_Series = new List <Contract_TvDB_Series>();
foreach (TvDB_Series ser in tvseries)
{
contract.TvDB_Series.Add(ser.ToContract());
}
contract.CrossRefAniDBMovieDB = null;
if (movieDBCrossRef != null)
{
contract.CrossRefAniDBMovieDB = movieDBCrossRef.ToContract();
}
contract.CrossRefAniDBMAL = new List <Contract_CrossRef_AniDB_MAL>();
if (malDBCrossRef != null)
{
foreach (CrossRef_AniDB_MAL xref in malDBCrossRef)
{
contract.CrossRefAniDBMAL.Add(xref.ToContract());
}
}
return(contract);
}
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)
{
TraktTVShow showInfo = TraktTVHelper.GetShowInfo(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)
{
TraktTVShow showInfo = TraktTVHelper.GetShowInfo(tvXRef.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, (AniDBAPI.enEpisodeType)tvXRef.AniDBStartEpisodeType,
tvXRef.AniDBStartEpisodeNumber, showInfo.TraktID, 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 <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;
}
}
public override void ProcessCommand()
{
logger.Info("Get AniDB file info: {0}", VideoLocalID);
try
{
vlocal = RepoFactory.VideoLocal.GetByID(VideoLocalID);
if (vlocal == null)
{
return;
}
AniDB_File aniFile = RepoFactory.AniDB_File.GetByHashAndFileSize(vlocal.Hash, vlocal.FileSize);
/*// get anidb file info from web cache
* if (aniFile == null && ServerSettings.WebCache_AniDB_File_Get)
* {
* AniDB_FileRequest fr = XMLService.Get_AniDB_File(vlocal.Hash, vlocal.FileSize);
* if (fr != null)
* {
* aniFile = new AniDB_File();
* aniFile.Populate(fr);
*
* //overwrite with local file name
* string localFileName = Path.GetFileName(vlocal.FilePath);
* aniFile.FileName = localFileName;
*
* repAniFile.Save(aniFile, false);
* aniFile.CreateLanguages();
* aniFile.CreateCrossEpisodes(localFileName);
*
* StatsCache.Instance.UpdateUsingAniDBFile(vlocal.Hash);
* }
* }*/
Raw_AniDB_File fileInfo = null;
if (aniFile == null || ForceAniDB)
{
fileInfo = JMMService.AnidbProcessor.GetFileInfo(vlocal);
}
if (fileInfo != null)
{
// save to the database
if (aniFile == null)
{
aniFile = new AniDB_File();
}
aniFile.Populate(fileInfo);
//overwrite with local file name
string localFileName = vlocal.FileName;
aniFile.FileName = localFileName;
RepoFactory.AniDB_File.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();
}
}
}
AniDB_Anime anime = RepoFactory.AniDB_Anime.GetByAnimeID(aniFile.AnimeID);
if (anime != null)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
anime.UpdateContractDetailed(session.Wrap());
}
}
AnimeSeries series = RepoFactory.AnimeSeries.GetByAnimeID(aniFile.AnimeID);
series.UpdateStats(false, true, true);
// StatsCache.Instance.UpdateUsingAniDBFile(vlocal.Hash);
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_GetFile: {0} - {1}", VideoLocalID, ex.ToString());
return;
}
}
private static bool PopulateVideoEpisodeFromAnime(Video v, AniDB_Anime ani, Video nv)
{
bool ret = false;
if (ani != null)
{
if (ani.Restricted > 0)
{
v.ContentRating = "R";
}
if (ani.AnimeTypeEnum == enAnimeType.Movie)
{
v.Type = "movie";
if (v.Title.StartsWith("Complete Movie"))
{
v.Title = nv.Title;
v.Summary = nv.Summary;
v.Index = null;
ret = true;
}
else if (v.Title.StartsWith("Part "))
{
v.Title = nv.Title + " - " + v.Title;
v.Summary = nv.Summary;
}
v.Thumb = nv.Thumb;
}
else if (ani.AnimeTypeEnum == enAnimeType.OVA)
{
if (v.Title == "OVA")
{
v.Title = nv.Title;
v.Type = "movie";
v.Thumb = nv.Thumb;
v.Summary = nv.Summary;
v.Index = null;
ret = true;
}
}
else
{
v.ParentTitle = nv.Title;
}
}
if (string.IsNullOrEmpty(v.Art))
{
v.Art = nv.Art;
}
if (v.Tags == null)
{
v.Tags = nv.Tags;
}
if (v.Genres == null)
{
v.Genres = nv.Genres;
}
if (v.Season == null)
{
v.Season = nv.Season;
}
v.ParentThumb = nv.Thumb;
v.ParentRatingKey = v.ParentKey = nv.Key;
if (string.IsNullOrEmpty(v.Rating))
{
v.Rating = nv.Rating;
v.Votes = nv.Votes;
}
return(ret);
}
public static void MigrateTvDBLinks_V1_to_V2()
{
try
{
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
TvDB_EpisodeRepository repEps = new TvDB_EpisodeRepository();
CrossRef_AniDB_TvDBRepository repCrossRefTvDB = new CrossRef_AniDB_TvDBRepository();
CrossRef_AniDB_TvDBV2Repository repCrossRefTvDBNew = new CrossRef_AniDB_TvDBV2Repository();
using (var session = JMMService.SessionFactory.OpenSession())
{
List <CrossRef_AniDB_TvDB> xrefsTvDB = repCrossRefTvDB.GetAll();
foreach (CrossRef_AniDB_TvDB xrefTvDB in xrefsTvDB)
{
CrossRef_AniDB_TvDBV2 xrefNew = new CrossRef_AniDB_TvDBV2();
xrefNew.AnimeID = xrefTvDB.AnimeID;
xrefNew.CrossRefSource = xrefTvDB.CrossRefSource;
xrefNew.TvDBID = xrefTvDB.TvDBID;
xrefNew.TvDBSeasonNumber = xrefTvDB.TvDBSeasonNumber;
TvDB_Series ser = xrefTvDB.GetTvDBSeries(session);
if (ser != null)
{
xrefNew.TvDBTitle = ser.SeriesName;
}
// determine start ep type
if (xrefTvDB.TvDBSeasonNumber == 0)
{
xrefNew.AniDBStartEpisodeType = (int)AniDBAPI.enEpisodeType.Special;
}
else
{
xrefNew.AniDBStartEpisodeType = (int)AniDBAPI.enEpisodeType.Episode;
}
xrefNew.AniDBStartEpisodeNumber = 1;
xrefNew.TvDBStartEpisodeNumber = 1;
repCrossRefTvDBNew.Save(xrefNew);
}
// create cross ref's for specials
foreach (CrossRef_AniDB_TvDB xrefTvDB in xrefsTvDB)
{
AniDB_Anime anime = repAnime.GetByAnimeID(xrefTvDB.AnimeID);
if (anime == null)
{
continue;
}
// this anime has specials
if (anime.EpisodeCountSpecial <= 0)
{
continue;
}
// this tvdb series has a season 0 (specials)
List <int> seasons = repEps.GetSeasonNumbersForSeries(xrefTvDB.TvDBID);
if (!seasons.Contains(0))
{
continue;
}
//make sure we are not doubling up
CrossRef_AniDB_TvDBV2 temp = repCrossRefTvDBNew.GetByTvDBID(xrefTvDB.TvDBID, 0, 1, xrefTvDB.AnimeID, (int)AniDBAPI.enEpisodeType.Special, 1);
if (temp != null)
{
continue;
}
CrossRef_AniDB_TvDBV2 xrefNew = new CrossRef_AniDB_TvDBV2();
xrefNew.AnimeID = xrefTvDB.AnimeID;
xrefNew.CrossRefSource = xrefTvDB.CrossRefSource;
xrefNew.TvDBID = xrefTvDB.TvDBID;
xrefNew.TvDBSeasonNumber = 0;
xrefNew.TvDBStartEpisodeNumber = 1;
xrefNew.AniDBStartEpisodeType = (int)AniDBAPI.enEpisodeType.Special;
xrefNew.AniDBStartEpisodeNumber = 1;
TvDB_Series ser = xrefTvDB.GetTvDBSeries(session);
if (ser != null)
{
xrefNew.TvDBTitle = ser.SeriesName;
}
repCrossRefTvDBNew.Save(xrefNew);
}
}
}
catch (Exception ex)
{
logger.ErrorException("Could not MigrateTvDBLinks_V1_to_V2: " + ex.ToString(), ex);
}
}
public static bool PopulateVideo(Video l, VideoLocal v, AnimeEpisode ep, AnimeSeries series, AniDB_Anime ani, Video nv, JMMType type, int userid)
{
PopulateVideoEpisodeFromVideoLocal(l, v, type);
if (ep != null)
{
PopulateVideoEpisodeFromAnimeEpisode(l, ep, userid);
if (series != null)
{
return(PopulateVideoEpisodeFromAnime(l, ani, nv));
}
}
return(false);
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_TvDBSearchAnime: {0}", AnimeID);
try
{
using (var session = JMMService.SessionFactory.OpenSession())
{
// first check if the user wants to use the web cache
if (ServerSettings.WebCache_TvDB_Get)
{
try
{
List <JMMServer.Providers.Azure.CrossRef_AniDB_TvDB> cacheResults = JMMServer.Providers.Azure.AzureWebAPI.Get_CrossRefAniDBTvDB(AnimeID);
if (cacheResults != null && cacheResults.Count > 0)
{
// check again to see if there are any links, user may have manually added links while
// this command was in the queue
CrossRef_AniDB_TvDBV2Repository repCrossRef = new CrossRef_AniDB_TvDBV2Repository();
List <CrossRef_AniDB_TvDBV2> xrefTemp = repCrossRef.GetByAnimeID(AnimeID);
if (xrefTemp != null && xrefTemp.Count > 0)
{
return;
}
foreach (JMMServer.Providers.Azure.CrossRef_AniDB_TvDB xref in cacheResults)
{
TvDB_Series tvser = TvDBHelper.GetSeriesInfoOnline(cacheResults[0].TvDBID);
if (tvser != null)
{
logger.Trace("Found tvdb match on web cache for {0}", AnimeID);
TvDBHelper.LinkAniDBTvDB(AnimeID, (AniDBAPI.enEpisodeType)cacheResults[0].AniDBStartEpisodeType, cacheResults[0].AniDBStartEpisodeNumber,
cacheResults[0].TvDBID, cacheResults[0].TvDBSeasonNumber, cacheResults[0].TvDBStartEpisodeNumber, true);
}
else
{
//if we got a TvDB ID from the web cache, but couldn't find it on TheTvDB.com, it could mean 2 things
//1. thetvdb.com is offline
//2. the id is no longer valid
// if the id is no longer valid we should remove it from the web cache
/*if (TvDBHelper.ConfirmTvDBOnline())
* {
*
* }*/
}
}
return;
}
}
catch (Exception)
{
}
}
string searchCriteria = "";
AniDB_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
List <TVDBSeriesSearchResult> results = JMMService.TvdbHelper.SearchSeries(searchCriteria);
logger.Trace("Found {0} tvdb results for {1} on TheTvDB", results.Count, searchCriteria);
if (ProcessSearchResults(results, searchCriteria))
{
return;
}
if (results.Count == 0)
{
foreach (AniDB_Anime_Title title in anime.GetTitles())
{
if (title.TitleType.ToUpper() != Constants.AnimeTitleType.Official.ToUpper())
{
continue;
}
if (searchCriteria.ToUpper() == title.Title.ToUpper())
{
continue;
}
results = JMMService.TvdbHelper.SearchSeries(title.Title);
logger.Trace("Found {0} tvdb results for search on {1}", results.Count, title.Title);
if (ProcessSearchResults(results, title.Title))
{
return;
}
}
}
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_TvDBSearchAnime: {0} - {1}", AnimeID, ex.ToString());
return;
}
}
public System.IO.Stream GetImage(string ImageType, string ImageID, bool thumnbnailOnly, out string contentType)
{
contentType = null;
JMMImageType imageType = (JMMImageType)int.Parse(ImageType);
string path;
switch (imageType)
{
case JMMImageType.AniDB_Cover:
AniDB_Anime anime = RepoFactory.AniDB_Anime.GetByAnimeID(int.Parse(ImageID));
if (anime == null)
{
return(null);
}
path = anime.PosterPath;
if (File.Exists(path))
{
FileStream fs = File.OpenRead(path);
contentType = MimeTypes.GetMimeType(path);
return(fs);
}
else
{
logger.Trace("Could not find AniDB_Cover image: {0}", anime.PosterPath);
return(BlankImage());
}
case JMMImageType.AniDB_Character:
AniDB_Character chr = RepoFactory.AniDB_Character.GetByID(int.Parse(ImageID));
if (chr == null)
{
return(null);
}
path = chr.PosterPath;
if (File.Exists(path))
{
FileStream fs = File.OpenRead(path);
contentType = MimeTypes.GetMimeType(path);
return(fs);
}
else
{
logger.Trace("Could not find AniDB_Character image: {0}", chr.PosterPath);
return(BlankImage());
}
case JMMImageType.AniDB_Creator:
AniDB_Seiyuu creator = RepoFactory.AniDB_Seiyuu.GetByID(int.Parse(ImageID));
if (creator == null)
{
return(null);
}
path = creator.PosterPath;
if (File.Exists(path))
{
FileStream fs = File.OpenRead(path);
contentType = MimeTypes.GetMimeType(path);
return(fs);
}
else
{
logger.Trace("Could not find AniDB_Creator image: {0}", creator.PosterPath);
return(BlankImage());
}
case JMMImageType.TvDB_Cover:
TvDB_ImagePoster poster = RepoFactory.TvDB_ImagePoster.GetByID(int.Parse(ImageID));
if (poster == null)
{
return(null);
}
path = poster.FullImagePath;
if (File.Exists(path))
{
FileStream fs = File.OpenRead(path);
contentType = MimeTypes.GetMimeType(path);
return(fs);
}
else
{
logger.Trace("Could not find TvDB_Cover image: {0}", poster.FullImagePath);
return(BlankImage());
}
case JMMImageType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = RepoFactory.TvDB_ImageWideBanner.GetByID(int.Parse(ImageID));
if (wideBanner == null)
{
return(null);
}
path = wideBanner.FullImagePath;
if (File.Exists(path))
{
FileStream fs = File.OpenRead(path);
contentType = MimeTypes.GetMimeType(path);
return(fs);
}
else
{
logger.Trace("Could not find TvDB_Banner image: {0}", wideBanner.FullImagePath);
return(BlankImage());
}
case JMMImageType.TvDB_Episode:
TvDB_Episode ep = RepoFactory.TvDB_Episode.GetByID(int.Parse(ImageID));
if (ep == null)
{
return(null);
}
path = ep.FullImagePath;
if (File.Exists(path))
{
FileStream fs = File.OpenRead(path);
contentType = MimeTypes.GetMimeType(path);
return(fs);
}
else
{
logger.Trace("Could not find TvDB_Episode image: {0}", ep.FullImagePath);
return(BlankImage());
}
case JMMImageType.TvDB_FanArt:
TvDB_ImageFanart fanart = RepoFactory.TvDB_ImageFanart.GetByID(int.Parse(ImageID));
if (fanart == null)
{
return(null);
}
if (thumnbnailOnly)
{
path = fanart.FullThumbnailPath;
if (File.Exists(path))
{
FileStream fs = File.OpenRead(path);
contentType = MimeTypes.GetMimeType(path);
return(fs);
}
else
{
logger.Trace("Could not find TvDB_FanArt image: {0}", fanart.FullThumbnailPath);
return(null);
}
}
else
{
path = fanart.FullImagePath;
if (File.Exists(path))
{
FileStream fs = File.OpenRead(path);
contentType = MimeTypes.GetMimeType(path);
return(fs);
}
else
{
logger.Trace("Could not find TvDB_FanArt image: {0}", fanart.FullImagePath);
return(BlankImage());
}
}
case JMMImageType.MovieDB_Poster:
MovieDB_Poster mPoster = RepoFactory.MovieDB_Poster.GetByID(int.Parse(ImageID));
if (mPoster == null)
{
return(null);
}
// now find only the original size
mPoster = RepoFactory.MovieDB_Poster.GetByOnlineID(mPoster.URL);
if (mPoster == null)
{
return(null);
}
path = mPoster.FullImagePath;
if (File.Exists(path))
{
FileStream fs = File.OpenRead(path);
contentType = MimeTypes.GetMimeType(path);
return(fs);
}
else
{
logger.Trace("Could not find MovieDB_Poster image: {0}", mPoster.FullImagePath);
return(BlankImage());
}
case JMMImageType.MovieDB_FanArt:
MovieDB_Fanart mFanart = RepoFactory.MovieDB_Fanart.GetByID(int.Parse(ImageID));
if (mFanart == null)
{
return(null);
}
mFanart = RepoFactory.MovieDB_Fanart.GetByOnlineID(mFanart.URL);
if (mFanart == null)
{
return(null);
}
path = mFanart.FullImagePath;
if (File.Exists(path))
{
FileStream fs = File.OpenRead(path);
contentType = MimeTypes.GetMimeType(path);
return(fs);
}
else
{
logger.Trace("Could not find MovieDB_FanArt image: {0}", mFanart.FullImagePath);
return(BlankImage());
}
case JMMImageType.Trakt_Fanart:
Trakt_ImageFanart tFanart = RepoFactory.Trakt_ImageFanart.GetByID(int.Parse(ImageID));
if (tFanart == null)
{
return(null);
}
path = tFanart.FullImagePath;
if (File.Exists(path))
{
FileStream fs = File.OpenRead(path);
contentType = MimeTypes.GetMimeType(path);
return(fs);
}
else
{
logger.Trace("Could not find Trakt_Fanart image: {0}", tFanart.FullImagePath);
return(BlankImage());
}
case JMMImageType.Trakt_Poster:
Trakt_ImagePoster tPoster = RepoFactory.Trakt_ImagePoster.GetByID(int.Parse(ImageID));
if (tPoster == null)
{
return(null);
}
path = tPoster.FullImagePath;
if (File.Exists(path))
{
FileStream fs = File.OpenRead(path);
contentType = MimeTypes.GetMimeType(path);
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 = RepoFactory.Trakt_Episode.GetByID(int.Parse(ImageID));
if (tEpisode == null)
{
return(null);
}
path = tEpisode.FullImagePath;
if (File.Exists(path))
{
FileStream fs = File.OpenRead(path);
contentType = MimeTypes.GetMimeType(path);
return(fs);
}
else
{
logger.Trace("Could not find Trakt_Episode image: {0}", tEpisode.FullImagePath);
return(BlankImage());
}
default:
return(BlankImage());
}
}