public static AniDB_Seiyuu GetSeiyuu(this AniDB_Character character)
{
using (var session = DatabaseFactory.SessionFactory.OpenSession())
{
return(character.GetSeiyuu(session));
}
}
public static Metro_AniDB_Character ToContractMetro(this AniDB_Character character, ISession session,
AniDB_Anime_Character charRel)
{
Metro_AniDB_Character contract = new Metro_AniDB_Character
{
AniDB_CharacterID = character.AniDB_CharacterID,
CharID = character.CharID,
CharName = character.CharName,
CharKanjiName = character.CharKanjiName,
CharDescription = character.CharDescription,
CharType = charRel.CharType,
ImageType = (int)ImageEntityType.AniDB_Character,
ImageID = character.AniDB_CharacterID
};
AniDB_Seiyuu seiyuu = character.GetSeiyuu(session);
if (seiyuu != null)
{
contract.SeiyuuID = seiyuu.AniDB_SeiyuuID;
contract.SeiyuuName = seiyuu.SeiyuuName;
contract.SeiyuuImageType = (int)ImageEntityType.AniDB_Creator;
contract.SeiyuuImageID = seiyuu.AniDB_SeiyuuID;
}
return(contract);
}
public AniDB_Character GetCharacterInfoUDP(int charID)
{
if (!Login())
{
return(null);
}
enHelperActivityType ev = enHelperActivityType.NoSuchChar;
AniDBCommand_GetCharacterInfo getCharCmd = null;
lock (lockAniDBConnections)
{
getCharCmd = new AniDBCommand_GetCharacterInfo();
getCharCmd.Init(charID, true);
SetWaitingOnResponse(true);
ev = getCharCmd.Process(ref soUdp, ref remoteIpEndPoint, curSessionID, new UnicodeEncoding(true, false));
SetWaitingOnResponse(false);
}
AniDB_Character chr = null;
if (ev == enHelperActivityType.GotCharInfo && getCharCmd.CharInfo != null)
{
chr = RepoFactory.AniDB_Character.GetByCharID(charID);
if (chr == null)
{
chr = new AniDB_Character();
}
chr.PopulateFromUDP(getCharCmd.CharInfo);
RepoFactory.AniDB_Character.Save(chr);
}
return(chr);
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_GetCharacter: {0}", CharID);
try
{
AniDB_CharacterRepository repChar = new AniDB_CharacterRepository();
AniDB_Character chr = repChar.GetByCharID(CharID);
if (ForceRefresh || chr == null)
{
// redownload anime details from http ap so we can get an update character list
chr = JMMService.AnidbProcessor.GetCharacterInfoUDP(CharID);
}
if (chr != null || !string.IsNullOrEmpty(chr.PosterPath) && !File.Exists(chr.PosterPath))
{
CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(chr.AniDB_CharacterID, ImageEntityType.AniDB_Character, false);
cmd.Save();
}
}
catch (Exception ex)
{
logger.Error("Error processing CommandRequest_GetCharacter: {0} - {1}", CharID, ex.ToString());
return;
}
}
public AniDB_Character GetByCharID(ISession session, int id)
{
AniDB_Character cr = session
.CreateCriteria(typeof(AniDB_Character))
.Add(Restrictions.Eq("CharID", id))
.UniqueResult <AniDB_Character>();
return(cr);
}
private static void Populate(this AniDB_Character character, Raw_AniDB_Character rawChar)
{
character.CharID = rawChar.CharID;
character.CharDescription = rawChar.CharDescription;
character.CharKanjiName = rawChar.CharKanjiName;
character.CharName = rawChar.CharName;
character.PicName = rawChar.PicName;
character.CreatorListRaw = rawChar.CreatorListRaw;
}
public static string GetPosterPath(this AniDB_Character character)
{
if (String.IsNullOrEmpty(character.PicName))
{
return("");
}
return(System.IO.Path.Combine(ImageUtils.GetAniDBCharacterImagePath(character.CharID), character.PicName));
}
public static CL_AniDB_Character ToClient(this AniDB_Character character, string charType, AniDB_Seiyuu seiyuu)
{
CL_AniDB_Character contract = character.ToClient();
if (seiyuu != null)
{
contract.Seiyuu = seiyuu;
}
return(contract);
}
public static CL_AniDB_Character ToClient(this AniDB_Character c)
{
return(new CL_AniDB_Character
{
CharID = c.CharID,
PicName = c.PicName,
CreatorListRaw = c.CreatorListRaw,
CharName = c.CharName,
CharKanjiName = c.CharKanjiName,
CharDescription = c.CharDescription
});
}
public AnimeCharacterAndSeiyuu(int animeID, AniDB_Character character, AniDB_Seiyuu seiyuu = null, string characterType = null)
{
if (character == null)
{
throw new ArgumentNullException(nameof(character));
}
AnimeID = animeID;
Character = character;
Seiyuu = seiyuu;
CharacterType = characterType ?? String.Empty;
}
public void Save(AniDB_Character obj)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
session.SaveOrUpdate(obj);
transaction.Commit();
}
}
}
public static AniDB_Seiyuu GetSeiyuu(this AniDB_Character character, ISession session)
{
List <AniDB_Character_Seiyuu> charSeiyuus =
RepoFactory.AniDB_Character_Seiyuu.GetByCharID(session, character.CharID);
if (charSeiyuus.Count > 0)
{
// just use the first creator
return(RepoFactory.AniDB_Seiyuu.GetBySeiyuuID(session, charSeiyuus[0].SeiyuuID));
}
return(null);
}
public static AniDB_Seiyuu GetSeiyuu(this AniDB_Character character)
{
List <AniDB_Character_Seiyuu> charSeiyuus =
Repo.Instance.AniDB_Character_Seiyuu.GetByCharID(character.CharID);
if (charSeiyuus.Count > 0)
{
// just use the first creator
return(Repo.Instance.AniDB_Seiyuu.GetByID(charSeiyuus[0].SeiyuuID));
}
return(null);
}
private string GetFileName(ImageDownloadRequest req, bool thumbNailOnly)
{
switch (req.ImageType)
{
case ImageEntityType.AniDB_Cover:
SVR_AniDB_Anime anime = req.ImageData as SVR_AniDB_Anime;
return(anime.PosterPath);
case ImageEntityType.TvDB_Episode:
TvDB_Episode ep = req.ImageData as TvDB_Episode;
return(ep.GetFullImagePath());
case ImageEntityType.TvDB_FanArt:
TvDB_ImageFanart fanart = req.ImageData as TvDB_ImageFanart;
if (thumbNailOnly)
{
return(fanart.GetFullThumbnailPath());
}
else
{
return(fanart.GetFullImagePath());
}
case ImageEntityType.TvDB_Cover:
TvDB_ImagePoster poster = req.ImageData as TvDB_ImagePoster;
return(poster.GetFullImagePath());
case ImageEntityType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = req.ImageData as TvDB_ImageWideBanner;
return(wideBanner.GetFullImagePath());
case ImageEntityType.MovieDB_Poster:
MovieDB_Poster moviePoster = req.ImageData as MovieDB_Poster;
return(moviePoster.GetFullImagePath());
case ImageEntityType.MovieDB_FanArt:
MovieDB_Fanart movieFanart = req.ImageData as MovieDB_Fanart;
return(movieFanart.GetFullImagePath());
case ImageEntityType.AniDB_Character:
AniDB_Character chr = req.ImageData as AniDB_Character;
return(chr.GetPosterPath());
case ImageEntityType.AniDB_Creator:
AniDB_Seiyuu creator = req.ImageData as AniDB_Seiyuu;
return(creator.GetPosterPath());
default:
return(string.Empty);
}
}
public static string GetFileURL(ImageDownloadRequest req, bool thumbNailOnly)
{
switch (req.ImageType)
{
case ImageEntityType.TvDB_Episode:
TvDB_Episode ep = req.ImageData as TvDB_Episode;
return(string.Format(Constants.URLS.TvDB_Images, ep.Filename));
case ImageEntityType.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 ImageEntityType.TvDB_Cover:
TvDB_ImagePoster poster = req.ImageData as TvDB_ImagePoster;
return(string.Format(Constants.URLS.TvDB_Images, poster.BannerPath));
case ImageEntityType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = req.ImageData as TvDB_ImageWideBanner;
return(string.Format(Constants.URLS.TvDB_Images, wideBanner.BannerPath));
case ImageEntityType.MovieDB_Poster:
MovieDB_Poster moviePoster = req.ImageData as MovieDB_Poster;
return(string.Format(Constants.URLS.MovieDB_Images, moviePoster.URL));
case ImageEntityType.MovieDB_FanArt:
MovieDB_Fanart movieFanart = req.ImageData as MovieDB_Fanart;
return(string.Format(Constants.URLS.MovieDB_Images, movieFanart.URL));
case ImageEntityType.AniDB_Cover:
SVR_AniDB_Anime anime = req.ImageData as SVR_AniDB_Anime;
return(string.Format(Constants.URLS.AniDB_Images, anime.Picname));
case ImageEntityType.AniDB_Character:
AniDB_Character chr = req.ImageData as AniDB_Character;
return(string.Format(Constants.URLS.AniDB_Images, chr.PicName));
case ImageEntityType.AniDB_Creator:
AniDB_Seiyuu creator = req.ImageData as AniDB_Seiyuu;
return(string.Format(Constants.URLS.AniDB_Images, creator.PicName));
default:
return(string.Empty);
}
}
public static void PopulateFromUDP(this AniDB_Character character, Raw_AniDB_Character rawChar)
{
if (character.CharID == 0) // a new object
{
character.Populate(rawChar);
}
else
{
// only update the fields that com from UDP API
character.CharKanjiName = rawChar.CharKanjiName;
character.CharName = rawChar.CharName;
//this.CreatorListRaw = rawChar.CreatorListRaw;
}
}
public static void PopulateFromHTTP(this AniDB_Character character, Raw_AniDB_Character rawChar)
{
if (character.CharID == 0) // a new object
{
character.Populate(rawChar);
}
else
{
// only update the fields that come from HTTP API
character.CharDescription = rawChar.CharDescription;
character.CharName = rawChar.CharName;
character.CreatorListRaw = rawChar.CreatorListRaw;
character.PicName = rawChar.PicName;
}
}
public void Delete(int id)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
AniDB_Character cr = GetByID(id);
if (cr != null)
{
session.Delete(cr);
transaction.Commit();
}
}
}
}
//experiment
private List <Character> GetCharactersFromAniDB(AniDB_Anime anidb_anime)
{
List <Character> char_list = new List <Character>();
foreach (AniDB_Anime_Character achar in anidb_anime.GetAnimeCharacters())
{
AniDB_Character x = achar.GetCharacter();
Character c = new Character();
c.CharID = x.AniDB_CharacterID;
c.CharName = x.CharName;
c.Description = x.CharDescription;
c.Picture = KodiHelper.ServerUrl(int.Parse(ServerSettings.JMMServerPort), MainWindow.PathAddressREST + "/GetImage/2/" + c.CharID);
c.SeiyuuName = "";
c.SeiyuuPic = "";
char_list.Add(c);
}
return(char_list);
}
public static bool PopulateFromUDP(this AniDB_Character character, Raw_AniDB_Character rawChar)
{
if (character.CharID == 0) // a new object
{
return(character.Populate(rawChar));
}
else
{
if (string.IsNullOrEmpty(rawChar?.CharKanjiName) || string.IsNullOrEmpty(rawChar.CharName))
{
return(false);
}
// only update the fields that com from UDP API
character.CharKanjiName = rawChar.CharKanjiName;
character.CharName = rawChar.CharName;
//this.CreatorListRaw = rawChar.CreatorListRaw;
}
return(true);
}
private static bool Populate(this AniDB_Character character, Raw_AniDB_Character rawChar)
{
if (rawChar == null)
{
return(false);
}
if (rawChar.CharID <= 0 || string.IsNullOrEmpty(rawChar.CharName))
{
return(false);
}
character.CharID = rawChar.CharID;
character.CharDescription = rawChar.CharDescription ?? string.Empty;
character.CharKanjiName = rawChar.CharKanjiName ?? string.Empty;
character.CharName = rawChar.CharName;
character.PicName = rawChar.PicName ?? string.Empty;
character.CreatorListRaw = rawChar.CreatorListRaw ?? string.Empty;
return(true);
}
public static bool PopulateFromHTTP(this AniDB_Character character, Raw_AniDB_Character rawChar)
{
if (character.CharID == 0) // a new object
{
return(character.Populate(rawChar));
}
else
{
// only update the fields that come from HTTP API
if (string.IsNullOrEmpty(rawChar?.CharName))
{
return(false);
}
character.CharDescription = rawChar.CharDescription ?? string.Empty;
character.CharName = rawChar.CharName;
character.CreatorListRaw = rawChar.CreatorListRaw ?? string.Empty;
character.PicName = rawChar.PicName ?? string.Empty;
}
return(true);
}
private string GetFileName(ImageDownloadRequest req, bool thumbNailOnly)
{
switch (req.ImageType)
{
case ImageEntityType.AniDB_Cover:
SVR_AniDB_Anime anime = req.ImageData as SVR_AniDB_Anime;
return(anime.PosterPath);
case ImageEntityType.AniDB_Character:
AniDB_Character chr = req.ImageData as AniDB_Character;
return(chr.GetPosterPath());
case ImageEntityType.AniDB_Creator:
AniDB_Seiyuu creator = req.ImageData as AniDB_Seiyuu;
return(creator.GetPosterPath());
default:
return(string.Empty);
}
}
public static Azure_AnimeCharacter ToContractAzure(this AniDB_Character character,
AniDB_Anime_Character charRel)
{
Azure_AnimeCharacter contract = new Azure_AnimeCharacter
{
CharID = character.CharID,
CharName = character.CharName,
CharKanjiName = character.CharKanjiName,
CharDescription = character.CharDescription,
CharType = charRel.CharType,
CharImageURL = string.Format(Constants.URLS.AniDB_Images, character.PicName)
};
AniDB_Seiyuu seiyuu = character.GetSeiyuu();
if (seiyuu != null)
{
contract.SeiyuuID = seiyuu.AniDB_SeiyuuID;
contract.SeiyuuName = seiyuu.SeiyuuName;
contract.SeiyuuImageURL = string.Format(Constants.URLS.AniDB_Images, seiyuu.PicName);
}
return(contract);
}
public static CL_AniDB_Character ToClient(this AniDB_Character character, string charType)
{
AniDB_Seiyuu seiyuu = character.GetSeiyuu();
return(character.ToClient(charType, seiyuu));
}
public override void ProcessCommand()
{
logger.Info("Processing CommandRequest_DownloadImage: {0}", EntityID);
string downloadURL = "";
try
{
ImageDownloadRequest req = null;
switch (EntityTypeEnum)
{
case JMMImageType.AniDB_Cover:
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
AniDB_Anime anime = repAnime.GetByID(EntityID);
if (anime == null)
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, anime, ForceDownload);
break;
case JMMImageType.TvDB_Episode:
TvDB_EpisodeRepository repTvEp = new TvDB_EpisodeRepository();
TvDB_Episode ep = repTvEp.GetByID(EntityID);
if (ep == null)
{
return;
}
if (string.IsNullOrEmpty(ep.Filename))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, ep, ForceDownload);
break;
case JMMImageType.TvDB_FanArt:
TvDB_ImageFanartRepository repFanart = new TvDB_ImageFanartRepository();
TvDB_ImageFanart fanart = repFanart.GetByID(EntityID);
if (fanart == null)
{
return;
}
if (string.IsNullOrEmpty(fanart.BannerPath))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, fanart, ForceDownload);
break;
case JMMImageType.TvDB_Cover:
TvDB_ImagePosterRepository repPoster = new TvDB_ImagePosterRepository();
TvDB_ImagePoster poster = repPoster.GetByID(EntityID);
if (poster == null)
{
return;
}
if (string.IsNullOrEmpty(poster.BannerPath))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, poster, ForceDownload);
break;
case JMMImageType.TvDB_Banner:
TvDB_ImageWideBannerRepository repBanners = new TvDB_ImageWideBannerRepository();
TvDB_ImageWideBanner wideBanner = repBanners.GetByID(EntityID);
if (wideBanner == null)
{
return;
}
if (string.IsNullOrEmpty(wideBanner.BannerPath))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, wideBanner, ForceDownload);
break;
case JMMImageType.MovieDB_Poster:
MovieDB_PosterRepository repMoviePosters = new MovieDB_PosterRepository();
MovieDB_Poster moviePoster = repMoviePosters.GetByID(EntityID);
if (moviePoster == null)
{
return;
}
if (string.IsNullOrEmpty(moviePoster.URL))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, moviePoster, ForceDownload);
break;
case JMMImageType.MovieDB_FanArt:
MovieDB_FanartRepository repMovieFanart = new MovieDB_FanartRepository();
MovieDB_Fanart movieFanart = repMovieFanart.GetByID(EntityID);
if (movieFanart == null)
{
return;
}
if (string.IsNullOrEmpty(movieFanart.URL))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, movieFanart, ForceDownload);
break;
case JMMImageType.Trakt_Poster:
Trakt_ImagePosterRepository repTraktPosters = new Trakt_ImagePosterRepository();
Trakt_ImagePoster traktPoster = repTraktPosters.GetByID(EntityID);
if (traktPoster == null)
{
return;
}
if (string.IsNullOrEmpty(traktPoster.ImageURL))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, traktPoster, ForceDownload);
break;
case JMMImageType.Trakt_Fanart:
Trakt_ImageFanartRepository repTraktFanarts = new Trakt_ImageFanartRepository();
Trakt_ImageFanart traktFanart = repTraktFanarts.GetByID(EntityID);
if (traktFanart == null)
{
return;
}
if (string.IsNullOrEmpty(traktFanart.ImageURL))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, traktFanart, ForceDownload);
break;
case JMMImageType.Trakt_Friend:
Trakt_FriendRepository repFriends = new Trakt_FriendRepository();
Trakt_Friend friend = repFriends.GetByID(EntityID);
if (friend == null)
{
return;
}
if (string.IsNullOrEmpty(friend.Avatar))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, friend, ForceDownload);
break;
case JMMImageType.Trakt_Episode:
Trakt_EpisodeRepository repTraktEpisodes = new Trakt_EpisodeRepository();
Trakt_Episode traktEp = repTraktEpisodes.GetByID(EntityID);
if (traktEp == null)
{
return;
}
if (string.IsNullOrEmpty(traktEp.EpisodeImage))
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, traktEp, ForceDownload);
break;
case JMMImageType.AniDB_Character:
AniDB_CharacterRepository repChars = new AniDB_CharacterRepository();
AniDB_Character chr = repChars.GetByID(EntityID);
if (chr == null)
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, chr, ForceDownload);
break;
case JMMImageType.AniDB_Creator:
AniDB_SeiyuuRepository repCreator = new AniDB_SeiyuuRepository();
AniDB_Seiyuu creator = repCreator.GetByID(EntityID);
if (creator == null)
{
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, creator, ForceDownload);
break;
}
if (req == null)
{
return;
}
List <string> fileNames = new List <string>();
List <string> downloadURLs = new List <string>();
string fileNameTemp = GetFileName(req, false);
string downloadURLTemp = GetFileURL(req, false);
fileNames.Add(fileNameTemp);
downloadURLs.Add(downloadURLTemp);
if (req.ImageType == JMMImageType.TvDB_FanArt)
{
fileNameTemp = GetFileName(req, true);
downloadURLTemp = GetFileURL(req, true);
fileNames.Add(fileNameTemp);
downloadURLs.Add(downloadURLTemp);
}
for (int i = 0; i < fileNames.Count; i++)
{
string fileName = fileNames[i];
downloadURL = downloadURLs[i];
bool downloadImage = true;
bool fileExists = File.Exists(fileName);
if (fileExists)
{
if (!req.ForceDownload)
{
downloadImage = false;
}
else
{
downloadImage = true;
}
}
else
{
downloadImage = true;
}
if (downloadImage)
{
string tempName = Path.Combine(ImageUtils.GetImagesTempFolder(), Path.GetFileName(fileName));
if (File.Exists(tempName))
{
File.Delete(tempName);
}
try
{
if (fileExists)
{
File.Delete(fileName);
}
}
catch (Exception ex)
{
Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(ServerSettings.Culture);
string msg = string.Format(JMMServer.Properties.Resources.Command_DeleteError, fileName,
ex.Message);
logger.Warn(msg);
return;
}
// download image
using (WebClient client = new WebClient())
{
client.Headers.Add("user-agent", "JMM");
//OnImageDownloadEvent(new ImageDownloadEventArgs("", req, ImageDownloadEventType.Started));
//BaseConfig.MyAnimeLog.Write("ProcessImages: Download: {0} *** to *** {1}", req.URL, fullName);
if (downloadURL.Length > 0)
{
client.DownloadFile(downloadURL, tempName);
string extension = "";
string contentType = client.ResponseHeaders["Content-type"].ToLower();
if (contentType.IndexOf("gif") >= 0)
{
extension = ".gif";
}
if (contentType.IndexOf("jpg") >= 0)
{
extension = ".jpg";
}
if (contentType.IndexOf("jpeg") >= 0)
{
extension = ".jpg";
}
if (contentType.IndexOf("bmp") >= 0)
{
extension = ".bmp";
}
if (contentType.IndexOf("png") >= 0)
{
extension = ".png";
}
if (extension.Length > 0)
{
string newFile = Path.ChangeExtension(tempName, extension);
if (!newFile.ToLower().Equals(tempName.ToLower()))
{
try
{
System.IO.File.Delete(newFile);
}
catch
{
//BaseConfig.MyAnimeLog.Write("DownloadedImage:Download() Delete failed:{0}", newFile);
}
System.IO.File.Move(tempName, newFile);
tempName = newFile;
}
}
}
}
// move the file to it's final location
// check that the final folder exists
string fullPath = Path.GetDirectoryName(fileName);
if (!Directory.Exists(fullPath))
{
Directory.CreateDirectory(fullPath);
}
System.IO.File.Move(tempName, fileName);
logger.Info("Image downloaded: {0}", fileName);
}
}
}
catch (Exception ex)
{
logger.Warn("Error processing CommandRequest_DownloadImage: {0} ({1}) - {2}", downloadURL, EntityID,
ex.Message);
return;
}
}
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 System.IO.Stream GetImage(string ImageType, string ImageID)
{
AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
TvDB_ImagePosterRepository repPosters = new TvDB_ImagePosterRepository();
TvDB_EpisodeRepository repEpisodes = new TvDB_EpisodeRepository();
TvDB_ImageFanartRepository repFanart = new TvDB_ImageFanartRepository();
TvDB_ImageWideBannerRepository repWideBanners = new TvDB_ImageWideBannerRepository();
MovieDB_PosterRepository repMoviePosters = new MovieDB_PosterRepository();
MovieDB_FanartRepository repMovieFanart = new MovieDB_FanartRepository();
Trakt_ImageFanartRepository repTraktFanart = new Trakt_ImageFanartRepository();
Trakt_ImagePosterRepository repTraktPosters = new Trakt_ImagePosterRepository();
Trakt_EpisodeRepository repTraktEpisodes = new Trakt_EpisodeRepository();
Trakt_FriendRepository repTraktFriends = new Trakt_FriendRepository();
JMMImageType imageType = (JMMImageType)int.Parse(ImageType);
switch (imageType)
{
case JMMImageType.AniDB_Cover:
AniDB_Anime anime = repAnime.GetByAnimeID(int.Parse(ImageID));
if (anime == null)
{
return(null);
}
if (File.Exists(anime.PosterPath))
{
FileStream fs = File.OpenRead(anime.PosterPath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find AniDB_Cover image: {0}", anime.PosterPath);
return(BlankImage());
}
case JMMImageType.AniDB_Character:
AniDB_CharacterRepository repChar = new AniDB_CharacterRepository();
AniDB_Character chr = repChar.GetByID(int.Parse(ImageID));
if (chr == null)
{
return(null);
}
if (File.Exists(chr.PosterPath))
{
FileStream fs = File.OpenRead(chr.PosterPath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find AniDB_Character image: {0}", chr.PosterPath);
return(BlankImage());
}
case JMMImageType.AniDB_Creator:
AniDB_SeiyuuRepository repCreator = new AniDB_SeiyuuRepository();
AniDB_Seiyuu creator = repCreator.GetByID(int.Parse(ImageID));
if (creator == null)
{
return(null);
}
if (File.Exists(creator.PosterPath))
{
FileStream fs = File.OpenRead(creator.PosterPath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find AniDB_Creator image: {0}", creator.PosterPath);
return(BlankImage());
}
case JMMImageType.TvDB_Cover:
TvDB_ImagePoster poster = repPosters.GetByID(int.Parse(ImageID));
if (poster == null)
{
return(null);
}
if (File.Exists(poster.FullImagePath))
{
FileStream fs = File.OpenRead(poster.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find TvDB_Cover image: {0}", poster.FullImagePath);
return(BlankImage());
}
case JMMImageType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = repWideBanners.GetByID(int.Parse(ImageID));
if (wideBanner == null)
{
return(null);
}
if (File.Exists(wideBanner.FullImagePath))
{
FileStream fs = File.OpenRead(wideBanner.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find TvDB_Banner image: {0}", wideBanner.FullImagePath);
return(BlankImage());
}
case JMMImageType.TvDB_Episode:
TvDB_Episode ep = repEpisodes.GetByID(int.Parse(ImageID));
if (ep == null)
{
return(null);
}
if (File.Exists(ep.FullImagePath))
{
FileStream fs = File.OpenRead(ep.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find TvDB_Episode image: {0}", ep.FullImagePath);
return(BlankImage());
}
case JMMImageType.TvDB_FanArt:
TvDB_ImageFanart fanart = repFanart.GetByID(int.Parse(ImageID));
if (fanart == null)
{
return(null);
}
if (File.Exists(fanart.FullImagePath))
{
FileStream fs = File.OpenRead(fanart.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find TvDB_FanArt image: {0}", fanart.FullImagePath);
return(BlankImage());
}
case JMMImageType.MovieDB_Poster:
MovieDB_Poster mPoster = repMoviePosters.GetByID(int.Parse(ImageID));
if (mPoster == null)
{
return(null);
}
// now find only the original size
mPoster = repMoviePosters.GetByOnlineID(mPoster.URL);
if (mPoster == null)
{
return(null);
}
if (File.Exists(mPoster.FullImagePath))
{
FileStream fs = File.OpenRead(mPoster.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find MovieDB_Poster image: {0}", mPoster.FullImagePath);
return(BlankImage());
}
case JMMImageType.MovieDB_FanArt:
MovieDB_Fanart mFanart = repMovieFanart.GetByID(int.Parse(ImageID));
if (mFanart == null)
{
return(null);
}
mFanart = repMovieFanart.GetByOnlineID(mFanart.URL);
if (mFanart == null)
{
return(null);
}
if (File.Exists(mFanart.FullImagePath))
{
FileStream fs = File.OpenRead(mFanart.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find MovieDB_FanArt image: {0}", mFanart.FullImagePath);
return(BlankImage());
}
case JMMImageType.Trakt_Fanart:
Trakt_ImageFanart tFanart = repTraktFanart.GetByID(int.Parse(ImageID));
if (tFanart == null)
{
return(null);
}
if (File.Exists(tFanart.FullImagePath))
{
FileStream fs = File.OpenRead(tFanart.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find Trakt_Fanart image: {0}", tFanart.FullImagePath);
return(BlankImage());
}
case JMMImageType.Trakt_Poster:
Trakt_ImagePoster tPoster = repTraktPosters.GetByID(int.Parse(ImageID));
if (tPoster == null)
{
return(null);
}
if (File.Exists(tPoster.FullImagePath))
{
FileStream fs = File.OpenRead(tPoster.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find Trakt_Poster image: {0}", tPoster.FullImagePath);
return(BlankImage());
}
case JMMImageType.Trakt_Episode:
case JMMImageType.Trakt_WatchedEpisode:
Trakt_Episode tEpisode = repTraktEpisodes.GetByID(int.Parse(ImageID));
if (tEpisode == null)
{
return(null);
}
if (File.Exists(tEpisode.FullImagePath))
{
FileStream fs = File.OpenRead(tEpisode.FullImagePath);
WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
return(fs);
}
else
{
logger.Trace("Could not find Trakt_Episode image: {0}", tEpisode.FullImagePath);
return(BlankImage());
}
default:
return(BlankImage());
}
}
public 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 override void ProcessCommand()
{
logger.Info("Processing CommandRequest_DownloadImage: {0}", EntityID);
string downloadURL = string.Empty;
try
{
ImageDownloadRequest req = null;
switch (EntityTypeEnum)
{
case ImageEntityType.TvDB_Episode:
TvDB_Episode ep = Repo.Instance.TvDB_Episode.GetByID(EntityID);
if (string.IsNullOrEmpty(ep?.Filename))
{
logger.Warn($"TvDB Episode image failed to download: Can't get episode with ID: {EntityID}");
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, ep, ForceDownload);
break;
case ImageEntityType.TvDB_FanArt:
TvDB_ImageFanart fanart = Repo.Instance.TvDB_ImageFanart.GetByID(EntityID);
if (string.IsNullOrEmpty(fanart?.BannerPath))
{
logger.Warn($"TvDB Fanart image failed to download: Can't find valid fanart with ID: {EntityID}");
RemoveImageRecord();
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, fanart, ForceDownload);
break;
case ImageEntityType.TvDB_Cover:
TvDB_ImagePoster poster = Repo.Instance.TvDB_ImagePoster.GetByID(EntityID);
if (string.IsNullOrEmpty(poster?.BannerPath))
{
logger.Warn($"TvDB Poster image failed to download: Can't find valid poster with ID: {EntityID}");
RemoveImageRecord();
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, poster, ForceDownload);
break;
case ImageEntityType.TvDB_Banner:
TvDB_ImageWideBanner wideBanner = Repo.Instance.TvDB_ImageWideBanner.GetByID(EntityID);
if (string.IsNullOrEmpty(wideBanner?.BannerPath))
{
logger.Warn($"TvDB Banner image failed to download: Can't find valid banner with ID: {EntityID}");
RemoveImageRecord();
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, wideBanner, ForceDownload);
break;
case ImageEntityType.MovieDB_Poster:
MovieDB_Poster moviePoster = Repo.Instance.MovieDB_Poster.GetByID(EntityID);
if (string.IsNullOrEmpty(moviePoster?.URL))
{
logger.Warn($"MovieDB Poster image failed to download: Can't find valid poster with ID: {EntityID}");
RemoveImageRecord();
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, moviePoster, ForceDownload);
break;
case ImageEntityType.MovieDB_FanArt:
MovieDB_Fanart movieFanart = Repo.Instance.MovieDB_Fanart.GetByID(EntityID);
if (string.IsNullOrEmpty(movieFanart?.URL))
{
logger.Warn($"MovieDB Fanart image failed to download: Can't find valid fanart with ID: {EntityID}");
return;
}
req = new ImageDownloadRequest(EntityTypeEnum, movieFanart, ForceDownload);
break;
case ImageEntityType.AniDB_Cover:
SVR_AniDB_Anime anime = Repo.Instance.AniDB_Anime.GetByAnimeID(EntityID);
if (anime == null)
{
logger.Warn($"AniDB poster image failed to download: Can't find AniDB_Anime with ID: {EntityID}");
return;
}
AniDbImageRateLimiter.Instance.EnsureRate();
req = new ImageDownloadRequest(EntityTypeEnum, anime, ForceDownload);
break;
case ImageEntityType.AniDB_Character:
AniDB_Character chr = Repo.Instance.AniDB_Character.GetByCharID(EntityID);
if (chr == null)
{
logger.Warn($"AniDB Character image failed to download: Can't find AniDB Character with ID: {EntityID}");
return;
}
AniDbImageRateLimiter.Instance.EnsureRate();
req = new ImageDownloadRequest(EntityTypeEnum, chr, ForceDownload);
break;
case ImageEntityType.AniDB_Creator:
AniDB_Seiyuu creator = Repo.Instance.AniDB_Seiyuu.GetBySeiyuuID(EntityID);
if (creator == null)
{
logger.Warn($"AniDB Seiyuu image failed to download: Can't find Seiyuu with ID: {EntityID}");
return;
}
AniDbImageRateLimiter.Instance.EnsureRate();
req = new ImageDownloadRequest(EntityTypeEnum, creator, ForceDownload);
break;
}
if (req == null)
{
logger.Warn($"Image failed to download: No implementation found for {EntityTypeEnum}");
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 == ImageEntityType.TvDB_FanArt)
{
fileNameTemp = GetFileName(req, true);
downloadURLTemp = GetFileURL(req, true);
fileNames.Add(fileNameTemp);
downloadURLs.Add(downloadURLTemp);
}
for (int i = 0; i < fileNames.Count; i++)
{
try
{
string fileName = fileNames[i];
downloadURL = downloadURLs[i];
bool downloadImage = true;
bool fileExists = File.Exists(fileName);
bool imageValid = fileExists && Misc.IsImageValid(fileName);
if (imageValid && !req.ForceDownload)
{
downloadImage = false;
}
if (!downloadImage)
{
continue;
}
string tempName = Path.Combine(ImageUtils.GetImagesTempFolder(), Path.GetFileName(fileName));
try
{
if (fileExists)
{
File.Delete(fileName);
}
}
catch (Exception ex)
{
Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(ServerSettings.Instance.Culture);
logger.Warn(Resources.Command_DeleteError, fileName, ex.Message);
return;
}
// If this has any issues, it will throw an exception, so the catch below will handle it
RecursivelyRetryDownload(downloadURL, ref tempName, 0, 5);
// 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);
}
File.Move(tempName, fileName);
logger.Info($"Image downloaded: {fileName} from {downloadURL}");
}
catch (WebException e)
{
logger.Warn("Error processing CommandRequest_DownloadImage: {0} ({1}) - {2}", downloadURL,
EntityID,
e.Message);
// Remove the record if the image doesn't exist or can't download
RemoveImageRecord();
}
}
}
catch (Exception ex)
{
logger.Warn("Error processing CommandRequest_DownloadImage: {0} ({1}) - {2}", downloadURL, EntityID,
ex.Message);
}
}
