Exemple #1
0
        public Trakt_Friend GetByUsername(ISession session, string username)
        {
            Trakt_Friend obj = session
                               .CreateCriteria(typeof(Trakt_Friend))
                               .Add(Restrictions.Eq("Username", username))
                               .UniqueResult <Trakt_Friend>();

            return(obj);
        }
Exemple #2
0
 public void Save(Trakt_Friend obj)
 {
     using (var session = JMMService.SessionFactory.OpenSession())
     {
         // populate the database
         using (var transaction = session.BeginTransaction())
         {
             session.SaveOrUpdate(obj);
             transaction.Commit();
         }
     }
 }
        public List <CL_Trakt_CommentUser> GetTraktCommentsForAnime(int animeID)
        {
            List <CL_Trakt_CommentUser> comments = new List <CL_Trakt_CommentUser>();

            try
            {
                List <TraktV2Comment> commentsTemp = TraktTVHelper.GetShowCommentsV2(animeID);
                if (commentsTemp == null || commentsTemp.Count == 0)
                {
                    return(comments);
                }

                foreach (TraktV2Comment sht in commentsTemp)
                {
                    CL_Trakt_CommentUser comment = new CL_Trakt_CommentUser();

                    Trakt_Friend traktFriend = RepoFactory.Trakt_Friend.GetByUsername(sht.user.username);

                    // user details
                    comment.User = new CL_Trakt_User();
                    if (traktFriend == null)
                    {
                        comment.User.Trakt_FriendID = 0;
                    }
                    else
                    {
                        comment.User.Trakt_FriendID = traktFriend.Trakt_FriendID;
                    }

                    comment.User.Username  = sht.user.username;
                    comment.User.Full_name = sht.user.name;

                    // comment details
                    comment.Comment = new CL_Trakt_Comment
                    {
                        CommentType = (int)TraktActivityType.Show, // episode or show
                        Text        = sht.comment,
                        Spoiler     = sht.spoiler,
                        Inserted    = sht.CreatedAtDate,

                        // urls
                        Comment_Url = string.Format(TraktURIs.WebsiteComment, sht.id)
                    };
                    comments.Add(comment);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, ex.ToString());
            }
            return(comments);
        }
        public static string GetFullImagePath(this Trakt_Friend friend)
        {
            // typical url
            // http://vicmackey.trakt.tv/images/avatars/837.jpg
            // http://gravatar.com/avatar/f894a4cbd5e8bcbb1a79010699af1183.jpg?s=140&r=pg&d=http%3A%2F%2Fvicmackey.trakt.tv%2Fimages%2Favatar-large.jpg

            if (String.IsNullOrEmpty(friend.Avatar))
            {
                return("");
            }

            string path = ImageUtils.GetTraktImagePath_Avatars();

            return(System.IO.Path.Combine(path, String.Format("{0}.jpg", friend.Username)));
        }
Exemple #5
0
 public void Delete(int id)
 {
     using (var session = JMMService.SessionFactory.OpenSession())
     {
         // populate the database
         using (var transaction = session.BeginTransaction())
         {
             Trakt_Friend cr = GetByID(id);
             if (cr != null)
             {
                 session.Delete(cr);
                 transaction.Commit();
             }
         }
     }
 }
Exemple #6
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;
            }
        }
Exemple #7
0
        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("");
            }
        }
Exemple #8
0
        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(string.Format(Constants.URLS.MovieDB_Images, moviePoster.URL));

            case JMMImageType.MovieDB_FanArt:

                MovieDB_Fanart movieFanart = req.ImageData as MovieDB_Fanart;
                return(string.Format(Constants.URLS.MovieDB_Images, 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("");
            }
        }
Exemple #9
0
 public static void Populate(this Trakt_Friend friend, TraktV2User user)
 {
     friend.Username         = user.username;
     friend.FullName         = user.name;
     friend.LastAvatarUpdate = DateTime.Now;
 }
        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(null);
                }

            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(null);
                }

            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(null);
                }

            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(null);
                }

            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(null);
                }

            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(null);
                }

            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(null);
                }

            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(null);
                }

            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(null);
                }

            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(null);
                }

            case JMMImageType.Trakt_Friend:


                Trakt_Friend tFriend = repTraktFriends.GetByID(int.Parse(ImageID));
                if (tFriend == null)
                {
                    return(null);
                }

                if (File.Exists(tFriend.FullImagePath))
                {
                    FileStream fs = File.OpenRead(tFriend.FullImagePath);
                    WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
                    return(fs);
                }
                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(ImageID));
                if (tFriendScrobble == null)
                {
                    return(null);
                }

                if (File.Exists(tFriendScrobble.FullImagePath))
                {
                    FileStream fs = File.OpenRead(tFriendScrobble.FullImagePath);
                    WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";
                    return(fs);
                }
                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(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(null);
                }

            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(null);
                }

            default:

                return(null);
            }
        }
Exemple #11
0
        public Contract_Trakt_Friend ToContract()
        {
            CrossRef_AniDB_TraktRepository repXrefTrakt = new CrossRef_AniDB_TraktRepository();
            CrossRef_AniDB_TvDBRepository  repXrefTvDB  = new CrossRef_AniDB_TvDBRepository();
            AniDB_AnimeRepository          repAnime     = new AniDB_AnimeRepository();
            AnimeSeriesRepository          repSeries    = new AnimeSeriesRepository();
            Trakt_FriendRepository         repFriends   = new Trakt_FriendRepository();
            Trakt_EpisodeRepository        repEpisodes  = new Trakt_EpisodeRepository();

            Trakt_Friend traktFriend = repFriends.GetByUsername(username);

            if (traktFriend == null)
            {
                return(null);
            }

            Contract_Trakt_Friend contract = new Contract_Trakt_Friend();

            contract.Trakt_FriendID = traktFriend.Trakt_FriendID;
            contract.Username       = username;
            contract.Full_name      = full_name;
            contract.Gender         = gender;
            contract.Age            = age;
            contract.Location       = location;
            contract.About          = about;
            contract.Joined         = joined;
            contract.Avatar         = avatar;
            contract.Url            = url;
            contract.JoinedDate     = Utils.GetAniDBDateAsDate(joined);



            contract.WatchedEpisodes = new List <Contract_Trakt_WatchedEpisode>();

            // we only care about the watched episodes
            foreach (TraktTVWatched wtch in watched)
            {
                if (wtch.episode != null)
                {
                    Contract_Trakt_WatchedEpisode watchedEp = new Contract_Trakt_WatchedEpisode();

                    watchedEp.Watched     = wtch.watched;
                    watchedEp.WatchedDate = Utils.GetAniDBDateAsDate(wtch.watched);

                    if (!contract.LastEpisodeWatched.HasValue)
                    {
                        contract.LastEpisodeWatched = watchedEp.WatchedDate;
                    }

                    if (watchedEp.WatchedDate.HasValue && watchedEp.WatchedDate > contract.LastEpisodeWatched)
                    {
                        contract.LastEpisodeWatched = watchedEp.WatchedDate;
                    }

                    watchedEp.AnimeSeriesID = null;

                    watchedEp.Episode_Number   = wtch.episode.number;
                    watchedEp.Episode_Overview = wtch.episode.overview;
                    watchedEp.Episode_Season   = wtch.episode.season;
                    watchedEp.Episode_Title    = wtch.episode.title;
                    watchedEp.Episode_Url      = wtch.episode.url;



                    if (wtch.episode.images != null)
                    {
                        watchedEp.Episode_Screenshot = wtch.episode.images.screen;
                    }

                    if (wtch.show != null)
                    {
                        watchedEp.TraktShow = wtch.show.ToContract();

                        // find the anime and series based on the trakt id
                        int?animeID = null;
                        CrossRef_AniDB_Trakt xref = repXrefTrakt.GetByTraktID(wtch.show.TraktID, int.Parse(wtch.episode.season));
                        if (xref != null)
                        {
                            animeID = xref.AnimeID;
                        }
                        else
                        {
                            // try the tvdb id instead
                            //TODO

                            /*
                             * CrossRef_AniDB_TvDB xrefTvDB = repXrefTvDB.GetByTvDBID(int.Parse(wtch.show.tvdb_id), int.Parse(wtch.episode.season));
                             * if (xrefTvDB != null)
                             *      animeID = xrefTvDB.AnimeID;*/
                        }

                        if (animeID.HasValue)
                        {
                            AnimeSeries ser = repSeries.GetByAnimeID(animeID.Value);
                            if (ser != null)
                            {
                                watchedEp.AnimeSeriesID = ser.AnimeSeriesID;
                            }

                            AniDB_Anime anime = repAnime.GetByAnimeID(animeID.Value);
                            if (anime != null)
                            {
                                watchedEp.Anime = anime.ToContract(true, null);
                            }
                        }
                    }



                    contract.WatchedEpisodes.Add(watchedEp);
                    break;                     // only show the latest show
                }
            }

            List <SortPropOrFieldAndDirection> sortCriteria = new List <SortPropOrFieldAndDirection>();

            sortCriteria.Add(new SortPropOrFieldAndDirection("WatchedDate", true, SortType.eDateTime));
            contract.WatchedEpisodes = Sorting.MultiSort <Contract_Trakt_WatchedEpisode>(contract.WatchedEpisodes, sortCriteria);

            return(contract);
        }
Exemple #12
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);
            }
        }