Exemple #1
0
        public override void ProcessCommand()
        {
            logger.Info("Processing CommandRequest_DownloadImage: {0}", EntityID);
            string downloadURL = "";

            try
            {
                ImageDownloadRequest req = null;
                switch (EntityTypeEnum)
                {
                case JMMImageType.AniDB_Cover:
                    AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
                    AniDB_Anime           anime    = repAnime.GetByID(EntityID);
                    if (anime == null)
                    {
                        return;
                    }

                    req = new ImageDownloadRequest(EntityTypeEnum, anime, ForceDownload);
                    break;

                case JMMImageType.TvDB_Episode:

                    TvDB_EpisodeRepository repTvEp = new TvDB_EpisodeRepository();
                    TvDB_Episode           ep      = repTvEp.GetByID(EntityID);
                    if (ep == null)
                    {
                        return;
                    }
                    if (string.IsNullOrEmpty(ep.Filename))
                    {
                        return;
                    }

                    req = new ImageDownloadRequest(EntityTypeEnum, ep, ForceDownload);
                    break;

                case JMMImageType.TvDB_FanArt:

                    TvDB_ImageFanartRepository repFanart = new TvDB_ImageFanartRepository();
                    TvDB_ImageFanart           fanart    = repFanart.GetByID(EntityID);
                    if (fanart == null)
                    {
                        return;
                    }
                    if (string.IsNullOrEmpty(fanart.BannerPath))
                    {
                        return;
                    }

                    req = new ImageDownloadRequest(EntityTypeEnum, fanart, ForceDownload);
                    break;

                case JMMImageType.TvDB_Cover:

                    TvDB_ImagePosterRepository repPoster = new TvDB_ImagePosterRepository();
                    TvDB_ImagePoster           poster    = repPoster.GetByID(EntityID);
                    if (poster == null)
                    {
                        return;
                    }
                    if (string.IsNullOrEmpty(poster.BannerPath))
                    {
                        return;
                    }

                    req = new ImageDownloadRequest(EntityTypeEnum, poster, ForceDownload);
                    break;

                case JMMImageType.TvDB_Banner:

                    TvDB_ImageWideBannerRepository repBanners = new TvDB_ImageWideBannerRepository();
                    TvDB_ImageWideBanner           wideBanner = repBanners.GetByID(EntityID);
                    if (wideBanner == null)
                    {
                        return;
                    }
                    if (string.IsNullOrEmpty(wideBanner.BannerPath))
                    {
                        return;
                    }

                    req = new ImageDownloadRequest(EntityTypeEnum, wideBanner, ForceDownload);
                    break;

                case JMMImageType.MovieDB_Poster:

                    MovieDB_PosterRepository repMoviePosters = new MovieDB_PosterRepository();
                    MovieDB_Poster           moviePoster     = repMoviePosters.GetByID(EntityID);
                    if (moviePoster == null)
                    {
                        return;
                    }
                    if (string.IsNullOrEmpty(moviePoster.URL))
                    {
                        return;
                    }

                    req = new ImageDownloadRequest(EntityTypeEnum, moviePoster, ForceDownload);
                    break;

                case JMMImageType.MovieDB_FanArt:

                    MovieDB_FanartRepository repMovieFanart = new MovieDB_FanartRepository();
                    MovieDB_Fanart           movieFanart    = repMovieFanart.GetByID(EntityID);
                    if (movieFanart == null)
                    {
                        return;
                    }
                    if (string.IsNullOrEmpty(movieFanart.URL))
                    {
                        return;
                    }

                    req = new ImageDownloadRequest(EntityTypeEnum, movieFanart, ForceDownload);
                    break;

                case JMMImageType.Trakt_Poster:

                    Trakt_ImagePosterRepository repTraktPosters = new Trakt_ImagePosterRepository();
                    Trakt_ImagePoster           traktPoster     = repTraktPosters.GetByID(EntityID);
                    if (traktPoster == null)
                    {
                        return;
                    }
                    if (string.IsNullOrEmpty(traktPoster.ImageURL))
                    {
                        return;
                    }

                    req = new ImageDownloadRequest(EntityTypeEnum, traktPoster, ForceDownload);
                    break;

                case JMMImageType.Trakt_Fanart:

                    Trakt_ImageFanartRepository repTraktFanarts = new Trakt_ImageFanartRepository();
                    Trakt_ImageFanart           traktFanart     = repTraktFanarts.GetByID(EntityID);
                    if (traktFanart == null)
                    {
                        return;
                    }
                    if (string.IsNullOrEmpty(traktFanart.ImageURL))
                    {
                        return;
                    }

                    req = new ImageDownloadRequest(EntityTypeEnum, traktFanart, ForceDownload);
                    break;

                case JMMImageType.Trakt_Friend:

                    Trakt_FriendRepository repFriends = new Trakt_FriendRepository();
                    Trakt_Friend           friend     = repFriends.GetByID(EntityID);
                    if (friend == null)
                    {
                        return;
                    }
                    if (string.IsNullOrEmpty(friend.Avatar))
                    {
                        return;
                    }

                    req = new ImageDownloadRequest(EntityTypeEnum, friend, ForceDownload);
                    break;

                case JMMImageType.Trakt_Episode:

                    Trakt_EpisodeRepository repTraktEpisodes = new Trakt_EpisodeRepository();
                    Trakt_Episode           traktEp          = repTraktEpisodes.GetByID(EntityID);
                    if (traktEp == null)
                    {
                        return;
                    }
                    if (string.IsNullOrEmpty(traktEp.EpisodeImage))
                    {
                        return;
                    }

                    req = new ImageDownloadRequest(EntityTypeEnum, traktEp, ForceDownload);
                    break;

                case JMMImageType.AniDB_Character:
                    AniDB_CharacterRepository repChars = new AniDB_CharacterRepository();
                    AniDB_Character           chr      = repChars.GetByID(EntityID);
                    if (chr == null)
                    {
                        return;
                    }

                    req = new ImageDownloadRequest(EntityTypeEnum, chr, ForceDownload);
                    break;

                case JMMImageType.AniDB_Creator:
                    AniDB_SeiyuuRepository repCreator = new AniDB_SeiyuuRepository();
                    AniDB_Seiyuu           creator    = repCreator.GetByID(EntityID);
                    if (creator == null)
                    {
                        return;
                    }

                    req = new ImageDownloadRequest(EntityTypeEnum, creator, ForceDownload);
                    break;
                }

                if (req == null)
                {
                    return;
                }

                List <string> fileNames    = new List <string>();
                List <string> downloadURLs = new List <string>();

                string fileNameTemp    = GetFileName(req, false);
                string downloadURLTemp = GetFileURL(req, false);

                fileNames.Add(fileNameTemp);
                downloadURLs.Add(downloadURLTemp);

                if (req.ImageType == JMMImageType.TvDB_FanArt)
                {
                    fileNameTemp    = GetFileName(req, true);
                    downloadURLTemp = GetFileURL(req, true);

                    fileNames.Add(fileNameTemp);
                    downloadURLs.Add(downloadURLTemp);
                }

                for (int i = 0; i < fileNames.Count; i++)
                {
                    string fileName = fileNames[i];
                    downloadURL = downloadURLs[i];

                    bool downloadImage = true;
                    bool fileExists    = File.Exists(fileName);

                    if (fileExists)
                    {
                        if (!req.ForceDownload)
                        {
                            downloadImage = false;
                        }
                        else
                        {
                            downloadImage = true;
                        }
                    }
                    else
                    {
                        downloadImage = true;
                    }

                    if (downloadImage)
                    {
                        string tempName = Path.Combine(ImageUtils.GetImagesTempFolder(), Path.GetFileName(fileName));
                        if (File.Exists(tempName))
                        {
                            File.Delete(tempName);
                        }


                        try
                        {
                            if (fileExists)
                            {
                                File.Delete(fileName);
                            }
                        }
                        catch (Exception ex)
                        {
                            Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(ServerSettings.Culture);

                            string msg = string.Format(JMMServer.Properties.Resources.Command_DeleteError, fileName,
                                                       ex.Message);
                            logger.Warn(msg);
                            return;
                        }


                        // download image
                        using (WebClient client = new WebClient())
                        {
                            client.Headers.Add("user-agent", "JMM");
                            //OnImageDownloadEvent(new ImageDownloadEventArgs("", req, ImageDownloadEventType.Started));
                            //BaseConfig.MyAnimeLog.Write("ProcessImages: Download: {0}  *** to ***  {1}", req.URL, fullName);
                            if (downloadURL.Length > 0)
                            {
                                client.DownloadFile(downloadURL, tempName);

                                string extension   = "";
                                string contentType = client.ResponseHeaders["Content-type"].ToLower();
                                if (contentType.IndexOf("gif") >= 0)
                                {
                                    extension = ".gif";
                                }
                                if (contentType.IndexOf("jpg") >= 0)
                                {
                                    extension = ".jpg";
                                }
                                if (contentType.IndexOf("jpeg") >= 0)
                                {
                                    extension = ".jpg";
                                }
                                if (contentType.IndexOf("bmp") >= 0)
                                {
                                    extension = ".bmp";
                                }
                                if (contentType.IndexOf("png") >= 0)
                                {
                                    extension = ".png";
                                }
                                if (extension.Length > 0)
                                {
                                    string newFile = Path.ChangeExtension(tempName, extension);
                                    if (!newFile.ToLower().Equals(tempName.ToLower()))
                                    {
                                        try
                                        {
                                            System.IO.File.Delete(newFile);
                                        }
                                        catch
                                        {
                                            //BaseConfig.MyAnimeLog.Write("DownloadedImage:Download() Delete failed:{0}", newFile);
                                        }
                                        System.IO.File.Move(tempName, newFile);
                                        tempName = newFile;
                                    }
                                }
                            }
                        }

                        // move the file to it's final location
                        // check that the final folder exists
                        string fullPath = Path.GetDirectoryName(fileName);
                        if (!Directory.Exists(fullPath))
                        {
                            Directory.CreateDirectory(fullPath);
                        }


                        System.IO.File.Move(tempName, fileName);
                        logger.Info("Image downloaded: {0}", fileName);
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Warn("Error processing CommandRequest_DownloadImage: {0} ({1}) - {2}", downloadURL, EntityID,
                            ex.Message);
                return;
            }
        }
        public 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());
            }
        }
Exemple #3
0
        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);
            }
        }
Exemple #4
0
        public Contract_AniDB_Anime_DefaultImage ToContract(ISession session)
        {
            Contract_AniDB_Anime_DefaultImage contract = new Contract_AniDB_Anime_DefaultImage();

            contract.AniDB_Anime_DefaultImageID = this.AniDB_Anime_DefaultImageID;
            contract.AnimeID         = this.AnimeID;
            contract.ImageParentID   = this.ImageParentID;
            contract.ImageParentType = this.ImageParentType;
            contract.ImageType       = this.ImageType;

            contract.MovieFanart  = null;
            contract.MoviePoster  = null;
            contract.TVPoster     = null;
            contract.TVFanart     = null;
            contract.TVWideBanner = null;
            contract.TraktFanart  = null;
            contract.TraktPoster  = null;

            JMMImageType imgType = (JMMImageType)ImageParentType;

            switch (imgType)
            {
            case JMMImageType.TvDB_Banner:

                TvDB_ImageWideBannerRepository repBanners = new TvDB_ImageWideBannerRepository();
                TvDB_ImageWideBanner           banner     = repBanners.GetByID(session, ImageParentID);
                if (banner != null)
                {
                    contract.TVWideBanner = banner.ToContract();
                }

                break;

            case JMMImageType.TvDB_Cover:

                TvDB_ImagePosterRepository repPosters = new TvDB_ImagePosterRepository();
                TvDB_ImagePoster           poster     = repPosters.GetByID(session, ImageParentID);
                if (poster != null)
                {
                    contract.TVPoster = poster.ToContract();
                }

                break;

            case JMMImageType.TvDB_FanArt:

                TvDB_ImageFanartRepository repFanart = new TvDB_ImageFanartRepository();
                TvDB_ImageFanart           fanart    = repFanart.GetByID(session, ImageParentID);
                if (fanart != null)
                {
                    contract.TVFanart = fanart.ToContract();
                }

                break;

            case JMMImageType.MovieDB_Poster:

                MovieDB_PosterRepository repMoviePosters = new MovieDB_PosterRepository();
                MovieDB_Poster           moviePoster     = repMoviePosters.GetByID(session, ImageParentID);
                if (moviePoster != null)
                {
                    contract.MoviePoster = moviePoster.ToContract();
                }

                break;

            case JMMImageType.MovieDB_FanArt:

                MovieDB_FanartRepository repMovieFanart = new MovieDB_FanartRepository();
                MovieDB_Fanart           movieFanart    = repMovieFanart.GetByID(session, ImageParentID);
                if (movieFanart != null)
                {
                    contract.MovieFanart = movieFanart.ToContract();
                }

                break;

            case JMMImageType.Trakt_Fanart:

                Trakt_ImageFanartRepository repTraktFanart = new Trakt_ImageFanartRepository();
                Trakt_ImageFanart           traktFanart    = repTraktFanart.GetByID(session, ImageParentID);
                if (traktFanart != null)
                {
                    contract.TraktFanart = traktFanart.ToContract();
                }

                break;

            case JMMImageType.Trakt_Poster:

                Trakt_ImagePosterRepository repTraktPoster = new Trakt_ImagePosterRepository();
                Trakt_ImagePoster           traktPoster    = repTraktPoster.GetByID(session, ImageParentID);
                if (traktPoster != null)
                {
                    contract.TraktPoster = traktPoster.ToContract();
                }

                break;
            }

            return(contract);
        }
Exemple #5
0
		public static void RunImport_GetImages()
		{
			// AniDB posters
			AniDB_AnimeRepository repAnime = new AniDB_AnimeRepository();
			foreach (AniDB_Anime anime in repAnime.GetAll())
			{
				if (anime.AnimeID == 8580)
					Console.Write("");

				if (string.IsNullOrEmpty(anime.PosterPath)) continue;

				bool fileExists = File.Exists(anime.PosterPath);
				if (!fileExists)
				{
					CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(anime.AniDB_AnimeID, JMMImageType.AniDB_Cover, false);
					cmd.Save();
				}
			}

			// TvDB Posters
			if (ServerSettings.TvDB_AutoPosters)
			{
				TvDB_ImagePosterRepository repTvPosters = new TvDB_ImagePosterRepository();
				Dictionary<int, int> postersCount = new Dictionary<int, int>();

				// build a dictionary of series and how many images exist
				List<TvDB_ImagePoster> allPosters = repTvPosters.GetAll();
				foreach (TvDB_ImagePoster tvPoster in allPosters)
				{
					if (string.IsNullOrEmpty(tvPoster.FullImagePath)) continue;
					bool fileExists = File.Exists(tvPoster.FullImagePath);

					if (fileExists)
					{
						if (postersCount.ContainsKey(tvPoster.SeriesID))
							postersCount[tvPoster.SeriesID] = postersCount[tvPoster.SeriesID] + 1;
						else
							postersCount[tvPoster.SeriesID] = 1;
					}
				}

				foreach (TvDB_ImagePoster tvPoster in allPosters)
				{
					if (string.IsNullOrEmpty(tvPoster.FullImagePath)) continue;
					bool fileExists = File.Exists(tvPoster.FullImagePath);

					int postersAvailable = 0;
					if (postersCount.ContainsKey(tvPoster.SeriesID))
						postersAvailable = postersCount[tvPoster.SeriesID];

					if (!fileExists && postersAvailable < ServerSettings.TvDB_AutoPostersAmount)
					{
						CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(tvPoster.TvDB_ImagePosterID, JMMImageType.TvDB_Cover, false);
						cmd.Save();

                        if (postersCount.ContainsKey(tvPoster.SeriesID))
                            postersCount[tvPoster.SeriesID] = postersCount[tvPoster.SeriesID] + 1;
                        else
                            postersCount[tvPoster.SeriesID] = 1;
					}
				}
			}

			// TvDB Fanart
			if (ServerSettings.TvDB_AutoFanart)
			{
				Dictionary<int, int> fanartCount = new Dictionary<int, int>();
				TvDB_ImageFanartRepository repTvFanart = new TvDB_ImageFanartRepository();

				List<TvDB_ImageFanart> allFanart = repTvFanart.GetAll();
				foreach (TvDB_ImageFanart tvFanart in allFanart)
				{
					// build a dictionary of series and how many images exist
					if (string.IsNullOrEmpty(tvFanart.FullImagePath)) continue;
					bool fileExists = File.Exists(tvFanart.FullImagePath);

					if (fileExists)
					{
						if (fanartCount.ContainsKey(tvFanart.SeriesID))
							fanartCount[tvFanart.SeriesID] = fanartCount[tvFanart.SeriesID] + 1;
						else
							fanartCount[tvFanart.SeriesID] = 1;
					}
				}

				foreach (TvDB_ImageFanart tvFanart in allFanart)
				{
					if (string.IsNullOrEmpty(tvFanart.FullImagePath)) continue;
					bool fileExists = File.Exists(tvFanart.FullImagePath);

					int fanartAvailable = 0;
					if (fanartCount.ContainsKey(tvFanart.SeriesID))
						fanartAvailable = fanartCount[tvFanart.SeriesID];

					if (!fileExists && fanartAvailable < ServerSettings.TvDB_AutoFanartAmount)
					{
						CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(tvFanart.TvDB_ImageFanartID, JMMImageType.TvDB_FanArt, false);
						cmd.Save();

                        if (fanartCount.ContainsKey(tvFanart.SeriesID))
                            fanartCount[tvFanart.SeriesID] = fanartCount[tvFanart.SeriesID] + 1;
                        else
                            fanartCount[tvFanart.SeriesID] = 1;
					}
				}
			}

			// TvDB Wide Banners
			if (ServerSettings.TvDB_AutoWideBanners)
			{
				TvDB_ImageWideBannerRepository repTvBanners = new TvDB_ImageWideBannerRepository();
				Dictionary<int, int> fanartCount = new Dictionary<int, int>();

				// build a dictionary of series and how many images exist
				List<TvDB_ImageWideBanner> allBanners = repTvBanners.GetAll();
				foreach (TvDB_ImageWideBanner tvBanner in allBanners)
				{
					if (string.IsNullOrEmpty(tvBanner.FullImagePath)) continue;
					bool fileExists = File.Exists(tvBanner.FullImagePath);

					if (fileExists)
					{
						if (fanartCount.ContainsKey(tvBanner.SeriesID))
							fanartCount[tvBanner.SeriesID] = fanartCount[tvBanner.SeriesID] + 1;
						else
							fanartCount[tvBanner.SeriesID] = 1;
					}
				}

				foreach (TvDB_ImageWideBanner tvBanner in allBanners)
				{
					if (string.IsNullOrEmpty(tvBanner.FullImagePath)) continue;
					bool fileExists = File.Exists(tvBanner.FullImagePath);

					int bannersAvailable = 0;
					if (fanartCount.ContainsKey(tvBanner.SeriesID))
						bannersAvailable = fanartCount[tvBanner.SeriesID];

					if (!fileExists && bannersAvailable < ServerSettings.TvDB_AutoWideBannersAmount)
					{
						CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(tvBanner.TvDB_ImageWideBannerID, JMMImageType.TvDB_Banner, false);
						cmd.Save();

                        if (fanartCount.ContainsKey(tvBanner.SeriesID))
                            fanartCount[tvBanner.SeriesID] = fanartCount[tvBanner.SeriesID] + 1;
                        else
                            fanartCount[tvBanner.SeriesID] = 1;
					}
				}
			}

			// TvDB Episodes
			TvDB_EpisodeRepository repTvEpisodes = new TvDB_EpisodeRepository();
			foreach (TvDB_Episode tvEpisode in repTvEpisodes.GetAll())
			{
				if (string.IsNullOrEmpty(tvEpisode.FullImagePath)) continue;
				bool fileExists = File.Exists(tvEpisode.FullImagePath);
				if (!fileExists)
				{
					CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(tvEpisode.TvDB_EpisodeID, JMMImageType.TvDB_Episode, false);
					cmd.Save();
				}
			}

			// MovieDB Posters
			if (ServerSettings.MovieDB_AutoPosters)
			{
				MovieDB_PosterRepository repMoviePosters = new MovieDB_PosterRepository();
				Dictionary<int, int> postersCount = new Dictionary<int, int>();

				// build a dictionary of series and how many images exist
				List<MovieDB_Poster> allPosters = repMoviePosters.GetAll();
				foreach (MovieDB_Poster moviePoster in allPosters)
				{
					if (string.IsNullOrEmpty(moviePoster.FullImagePath)) continue;
					bool fileExists = File.Exists(moviePoster.FullImagePath);

					if (fileExists)
					{
						if (postersCount.ContainsKey(moviePoster.MovieId))
							postersCount[moviePoster.MovieId] = postersCount[moviePoster.MovieId] + 1;
						else
							postersCount[moviePoster.MovieId] = 1;
					}
				}

				foreach (MovieDB_Poster moviePoster in allPosters)
				{
					if (string.IsNullOrEmpty(moviePoster.FullImagePath)) continue;
					bool fileExists = File.Exists(moviePoster.FullImagePath);

					int postersAvailable = 0;
					if (postersCount.ContainsKey(moviePoster.MovieId))
						postersAvailable = postersCount[moviePoster.MovieId];

					if (!fileExists && postersAvailable < ServerSettings.MovieDB_AutoPostersAmount)
					{
						CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(moviePoster.MovieDB_PosterID, JMMImageType.MovieDB_Poster, false);
						cmd.Save();

                        if (postersCount.ContainsKey(moviePoster.MovieId))
                            postersCount[moviePoster.MovieId] = postersCount[moviePoster.MovieId] + 1;
                        else
                            postersCount[moviePoster.MovieId] = 1;
					}
				}
			}

			// MovieDB Fanart
			if (ServerSettings.MovieDB_AutoFanart)
			{
				MovieDB_FanartRepository repMovieFanarts = new MovieDB_FanartRepository();
				Dictionary<int, int> fanartCount = new Dictionary<int, int>();

				// build a dictionary of series and how many images exist
				List<MovieDB_Fanart> allFanarts = repMovieFanarts.GetAll();
				foreach (MovieDB_Fanart movieFanart in allFanarts)
				{
					if (string.IsNullOrEmpty(movieFanart.FullImagePath)) continue;
					bool fileExists = File.Exists(movieFanart.FullImagePath);

					if (fileExists)
					{
						if (fanartCount.ContainsKey(movieFanart.MovieId))
							fanartCount[movieFanart.MovieId] = fanartCount[movieFanart.MovieId] + 1;
						else
							fanartCount[movieFanart.MovieId] = 1;
					}
				}

				foreach (MovieDB_Fanart movieFanart in repMovieFanarts.GetAll())
				{
					if (string.IsNullOrEmpty(movieFanart.FullImagePath)) continue;
					bool fileExists = File.Exists(movieFanart.FullImagePath);

					int fanartAvailable = 0;
					if (fanartCount.ContainsKey(movieFanart.MovieId))
						fanartAvailable = fanartCount[movieFanart.MovieId];

					if (!fileExists && fanartAvailable < ServerSettings.MovieDB_AutoFanartAmount)
					{
						CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(movieFanart.MovieDB_FanartID, JMMImageType.MovieDB_FanArt, false);
						cmd.Save();

                        if (fanartCount.ContainsKey(movieFanart.MovieId))
                            fanartCount[movieFanart.MovieId] = fanartCount[movieFanart.MovieId] + 1;
                        else
                            fanartCount[movieFanart.MovieId] = 1;
					}
				}
			}

			// Trakt Posters
			if (ServerSettings.Trakt_DownloadPosters)
			{
				Trakt_ImagePosterRepository repTraktPosters = new Trakt_ImagePosterRepository();
				foreach (Trakt_ImagePoster traktPoster in repTraktPosters.GetAll())
				{
					if (string.IsNullOrEmpty(traktPoster.FullImagePath)) continue;
					bool fileExists = File.Exists(traktPoster.FullImagePath);
					if (!fileExists)
					{
						CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(traktPoster.Trakt_ImagePosterID, JMMImageType.Trakt_Poster, false);
						cmd.Save();
					}
				}
			}

			// Trakt Fanart
			if (ServerSettings.Trakt_DownloadFanart)
			{
				Trakt_ImageFanartRepository repTraktFanarts = new Trakt_ImageFanartRepository();
				foreach (Trakt_ImageFanart traktFanart in repTraktFanarts.GetAll())
				{
					if (string.IsNullOrEmpty(traktFanart.FullImagePath)) continue;
					bool fileExists = File.Exists(traktFanart.FullImagePath);
					if (!fileExists)
					{
						CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(traktFanart.Trakt_ImageFanartID, JMMImageType.Trakt_Fanart, false);
						cmd.Save();
					}
				}
			}

			// Trakt Episode
			if (ServerSettings.Trakt_DownloadEpisodes)
			{
				Trakt_EpisodeRepository repTraktEpisodes = new Trakt_EpisodeRepository();
				foreach (Trakt_Episode traktEp in repTraktEpisodes.GetAll())
				{
					if (string.IsNullOrEmpty(traktEp.FullImagePath)) continue;
                    if (!traktEp.TraktID.HasValue) continue; // if it doesn't have a TraktID it means it is old data

					bool fileExists = File.Exists(traktEp.FullImagePath);
					if (!fileExists)
					{
						CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(traktEp.Trakt_EpisodeID, JMMImageType.Trakt_Episode, false);
						cmd.Save();
					}
				}
			}

			// AniDB Characters
			if (ServerSettings.AniDB_DownloadCharacters)
			{
				AniDB_CharacterRepository repChars = new AniDB_CharacterRepository();
				foreach (AniDB_Character chr in repChars.GetAll())
				{

                    if (chr.CharID == 75250)
                    {
                        Console.WriteLine("test");
                    }

					if (string.IsNullOrEmpty(chr.PosterPath)) continue;
					bool fileExists = File.Exists(chr.PosterPath);
					if (!fileExists)
					{
						CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(chr.AniDB_CharacterID, JMMImageType.AniDB_Character, false);
						cmd.Save();
					}
				}
			}

			// AniDB Creators
			if (ServerSettings.AniDB_DownloadCreators)
			{
				AniDB_SeiyuuRepository repSeiyuu = new AniDB_SeiyuuRepository();
				foreach (AniDB_Seiyuu seiyuu in repSeiyuu.GetAll())
				{
					if (string.IsNullOrEmpty(seiyuu.PosterPath)) continue;
					bool fileExists = File.Exists(seiyuu.PosterPath);
					if (!fileExists)
					{
						CommandRequest_DownloadImage cmd = new CommandRequest_DownloadImage(seiyuu.AniDB_SeiyuuID, JMMImageType.AniDB_Creator, false);
						cmd.Save();
					}
				}
			}
		}