public void TearDown()
 {
     parentalControls = null;
     allowedItem = null;
     lockedItem = null;
     customItem = null;
     unratedItem = null;
 }
 public void TestBackdropsAreDetected()
 {
     var movie = new Movie();
     movie.Path = @"..\..\SampleMedia\Movies\Flawless";
     ImageFromMediaLocationProvider provider = new ImageFromMediaLocationProvider();
     provider.Item = movie;
     Assert.IsTrue(provider.NeedsRefresh());
     provider.Fetch();
     Assert.AreEqual(2, movie.BackdropImagePaths.Count);
 }
Ejemplo n.º 3
0
        public override bool RefreshMetadata(MediaBrowser.Library.Metadata.MetadataRefreshOptions options)
        {
            if (RealMovie == null) RealMovie = (Movie)Kernel.Instance.ItemRepository.RetrieveItem(RealMovieID);
            MediaBrowser.Library.Logging.Logger.ReportInfo("Refreshing trailer for " + RealMovie.Name);
            this.PrimaryImagePath = Util.CloneImage(RealMovie.PrimaryImagePath);
            this.BackdropImagePaths = new List<string>();
            if (RealMovie.BackdropImagePaths != null)
            {
                foreach (string backdrop in RealMovie.BackdropImagePaths)
                {
                    this.BackdropImagePaths.Add(backdrop);
                }
            }
            if ((options & MetadataRefreshOptions.Force) == MetadataRefreshOptions.Force)
            {
                var images = new List<MediaBrowser.Library.ImageManagement.LibraryImage>();
                images.Add(PrimaryImage);
                images.AddRange(BackdropImages);

                foreach (var image in images)
                {
                    try
                    {
                        if (image != null)
                        {
                            image.ClearLocalImages();
                            MediaBrowser.Library.Factories.LibraryImageFactory.Instance.ClearCache(image.Path);
                        }
                    }
                    catch (Exception ex)
                    {
                        MediaBrowser.Library.Logging.Logger.ReportException("Failed to clear local image (its probably in use)", ex);
                    }
                }
                //changed = RealMovie.RefreshMetadata(options);
            }

            this.Overview = RealMovie.Overview;
            this.ProductionYear = RealMovie.ProductionYear;
            this.RunningTime = RealMovie.RunningTime;
            this.Actors = RealMovie.Actors;
            this.Directors = RealMovie.Directors;
            this.Name = RealMovie.Name + " " + Plugin.PluginOptions.Instance.TrailerSuffix;
            this.SortName = RealMovie.SortName;
            this.Studios = RealMovie.Studios;
            this.Path = RealMovie.TrailerFiles.First();
            this.MediaType = MediaTypeResolver.DetermineType(Path);
            this.MediaInfo = RealMovie.MediaInfo;
            this.DateCreated = System.IO.File.GetCreationTime(this.Path);
            this.DisplayMediaType = "Trailer";
            Plugin.proxy.SetTrailerInfo(this);
            Kernel.Instance.ItemRepository.SaveItem(this);

            return true;
        }
 public void SetUp()
 {
     parentalControls = new ParentalControl();
     allowedItem = new Movie();
     lockedItem = new Movie();
     customItem = new Movie();
     unratedItem = new Movie();
     allowedItem.MpaaRating = "G";
     lockedItem.MpaaRating = "R";
     customItem.MpaaRating = "R";
     customItem.CustomRating = "PG-13";
     unratedItem.MpaaRating = "";
 }
        public IEnumerable<string> GetTrailers(Movie movie)
        {
            var folder = movie.MediaLocation as IFolderMediaLocation;
            if (folder != null && folder.ContainsChild(MovieResolver.TrailersPath)) {

                var trailers = folder.GetChild(MovieResolver.TrailersPath) as IFolderMediaLocation;
                if (trailers != null) {
                    foreach (var path in Video.GetChildVideos(trailers, new string[] { MovieResolver.TrailersPath })) {
                        yield return path;
                    }
                }
            }
        }
        public void TestMediaInfoSavesProperly()
        {
            Movie movie = new Movie();
            movie.MediaInfo = new MediaInfoData();
            movie.MediaInfo.Height = 10;
            movie.MediaInfo.Width = 20;
            movie.MediaInfo.VideoCodec = "hello";
            movie.MediaInfo.AudioFormat = "goodby";
            movie.MediaInfo.VideoBitRate = 100;
            movie.MediaInfo.AudioBitRate = 200;

            var clone = Serializer.Clone(movie);
            Assert.AreEqual(clone.MediaInfo.Height, movie.MediaInfo.Height);
            Assert.AreEqual(clone.MediaInfo.Width, movie.MediaInfo.Width);
            Assert.AreEqual(clone.MediaInfo.VideoCodec, movie.MediaInfo.VideoCodec);
            Assert.AreEqual(clone.MediaInfo.AudioFormat, movie.MediaInfo.AudioFormat);
            Assert.AreEqual(clone.MediaInfo.VideoBitRate, movie.MediaInfo.VideoBitRate);
            Assert.AreEqual(clone.MediaInfo.AudioBitRate, movie.MediaInfo.AudioBitRate);
        }
        public void TestMoviePersistance()
        {
            var movie = new Movie();
            movie.Path = "c:\\test";
            movie.MediaType = MediaType.HDDVD;
            movie.Id = Guid.NewGuid();
            movie.Actors = new List<Actor>();
            movie.Actors.Add(new Actor() { Name = "Kevin Spacey" });
            movie.Actors.Add(new Actor() { Name = "Kevin Rudd", Role = "PM" });
            movie.Directors = new List<string>();
            movie.Directors.Add("hello");
            movie.Directors.Add("goodbye");

            Kernel.Instance.ItemRepository.SaveItem(movie);

            var copy = Kernel.Instance.ItemRepository.RetrieveItem(movie.Id) as Movie;

            Assert.IsInstanceOfType(typeof(Video), copy);
            Assert.AreEqual(movie.Path, copy.Path);
            Assert.AreEqual(movie.MediaType, copy.MediaType);
            Assert.AreEqual(movie.Id, copy.Id);

            Assert.AreEqual(2, copy.Actors.Count);
            Assert.AreEqual("Kevin Spacey", copy.Actors[0].Name);
            Assert.AreEqual("Kevin Rudd", copy.Actors[1].Name);
            Assert.AreEqual("PM", copy.Actors[1].Role);

            Assert.AreEqual(2, copy.Directors.Count);
            Assert.AreEqual(copy.Directors[0], "hello");
            Assert.AreEqual(copy.Directors[1], "goodbye");
        }