Represents all of the movie's details
상속: GalaSoft.MvvmLight.ObservableObject
예제 #1
0
        public void Equals_DifferentMovies_ReturnsFalse()
        {
            var fixture = new Fixture();

            var id1 = fixture.Create<int>();
            var dateUploadedUnix1 = fixture.Create<int>();

            var id2 = fixture.Create<int>();
            var dateUploadedUnix2 = fixture.Create<int>();

            var movie1 = new MovieFull
            {
                Id = id1,
                DateUploadedUnix = dateUploadedUnix1
            };

            var movie2 = new MovieFull
            {
                Id = id2,
                DateUploadedUnix = dateUploadedUnix2
            };

            Assert.AreEqual(
                _comparer.Equals(movie1, movie2), false);

            Assert.AreEqual(
                _comparer.Equals(movie1, null), false);

            Assert.AreEqual(
                _comparer.Equals(movie2, null), false);
        }
예제 #2
0
 /// <summary>
 /// Load a movie
 /// </summary>
 /// <param name="movie">Movie to load</param>
 public void LoadMovie(MovieFull movie)
 {
     Logger.Info(
         $"Loading movie: {movie.Title}.");
     Movie = movie;
     TabName = !string.IsNullOrEmpty(Movie.Title) ? Movie.Title : Properties.Resources.PlayingTitleTab;
 }
예제 #3
0
 /// <summary>
 /// Get the movie's subtitles
 /// </summary>
 /// <param name="movie">The movie</param>
 public async Task LoadSubtitlesAsync(MovieFull movie)
 {
     Logger.Debug(
         $"Load subtitles for movie: {movie.Title}");
     Movie = movie;
     await _movieService.LoadSubtitlesAsync(movie, _cancellationDownloadingSubtitlesToken.Token);
 }
예제 #4
0
        public void Equals_SameMovie_ReturnsTrue()
        {
            var fixture = new Fixture();

            var movie1 = new MovieFull();
            var movie2 = new MovieFull();

            var id = fixture.Create<int>();
            var dateUploadedUnix = fixture.Create<int>();

            movie1.Id = id;
            movie2.Id = id;
            movie1.DateUploadedUnix = dateUploadedUnix;
            movie2.DateUploadedUnix = dateUploadedUnix;

            Assert.AreEqual(
                _comparer.Equals(movie1, movie1), true);

            Assert.AreEqual(
                _comparer.Equals(movie1, movie2), true);
        }
예제 #5
0
        public void GetHashCode_SameMovie_ReturnsSameHashCode()
        {
            var fixture = new Fixture();

            var movie1 = new MovieFull();
            var movie2 = new MovieFull();

            var id = fixture.Create<int>();
            var dateUploadedUnix = fixture.Create<int>();

            movie1.Id = id;
            movie2.Id = id;
            movie1.DateUploadedUnix = dateUploadedUnix;
            movie2.DateUploadedUnix = dateUploadedUnix;

            Assert.AreEqual(
                _comparer.GetHashCode(movie1), _comparer.GetHashCode(movie1));

            Assert.AreEqual(
                _comparer.GetHashCode(movie1), _comparer.GetHashCode(movie2));
        }
예제 #6
0
 /// <summary>
 /// Stop downloading subtitles and clear movie
 /// </summary>
 public void ClearSubtitles()
 {
     StopDownloadingSubtitles();
     Movie = null;
 }
예제 #7
0
 /// <summary>
 /// Load a movie
 /// </summary>
 /// <param name="movie">The movie to load</param>
 public void LoadMovie(MovieFull movie)
 {
     Movie = movie;
     Subtitles.ClearSubtitles();
 }
예제 #8
0
        /// <summary>
        /// Download a movie asynchronously
        /// </summary>
        /// <param name="movie">The movie to download</param>
        /// <param name="downloadProgress">Report download progress</param>
        /// <param name="downloadRate">Report download rate</param>
        /// <param name="ct">Cancellation token</param>
        private async Task DownloadMovieAsync(MovieFull movie, IProgress<double> downloadProgress,
            IProgress<double> downloadRate,
            CancellationTokenSource ct)
        {
            await Task.Run(async () =>
            {
                using (var session = new session())
                {
                    Logger.Info(
                        $"Start downloading movie : {movie.Title}");

                    IsDownloadingMovie = true;

                    downloadProgress?.Report(0d);
                    downloadRate?.Report(0d);

                    session.listen_on(6881, 6889);
                    var torrentUrl = movie.WatchInFullHdQuality
                        ? movie.Torrents?.FirstOrDefault(torrent => torrent.Quality == "1080p")?.Url
                        : movie.Torrents?.FirstOrDefault(torrent => torrent.Quality == "720p")?.Url;

                    var result =
                        await
                            DownloadFileHelper.DownloadFileTaskAsync(torrentUrl,
                                Constants.TorrentDownloads + movie.ImdbCode + ".torrent", ct: ct);
                    var torrentPath = string.Empty;
                    if (result.Item3 == null && !string.IsNullOrEmpty(result.Item2))
                        torrentPath = result.Item2;

                    var addParams = new add_torrent_params
                    {
                        save_path = Constants.MovieDownloads,
                        ti = new torrent_info(torrentPath)
                    };

                    var handle = session.add_torrent(addParams);
                    handle.set_upload_limit(_settingsViewModel.DownloadLimit*1024);
                    handle.set_download_limit(_settingsViewModel.UploadLimit*1024);

                    // We have to download sequentially, so that we're able to play the movie without waiting
                    handle.set_sequential_download(true);
                    var alreadyBuffered = false;
                    while (IsDownloadingMovie)
                    {
                        var status = handle.status();
                        var progress = status.progress*100d;

                        downloadProgress?.Report(progress);
                        downloadRate?.Report(Math.Round(status.download_rate/1024d, 0));

                        handle.flush_cache();
                        if (handle.need_save_resume_data())
                            handle.save_resume_data(1);

                        if (progress >= Constants.MinimumBufferingBeforeMoviePlaying && !alreadyBuffered)
                        {
                            // Get movie file
                            foreach (
                                var filePath in
                                    Directory.GetFiles(status.save_path + handle.torrent_file().name(),
                                        "*" + Constants.VideoFileExtension)
                                )
                            {
                                alreadyBuffered = true;
                                movie.FilePath = new Uri(filePath);
                                Messenger.Default.Send(new PlayMovieMessage(movie));
                            }
                        }

                        try
                        {
                            await Task.Delay(1000, ct.Token);
                        }
                        catch (TaskCanceledException)
                        {
                            return;
                        }
                    }
                }
            }, ct.Token);
        }
예제 #9
0
 /// <summary>
 /// Load a movie
 /// </summary>
 /// <param name="movie">The movie to load</param>
 public void LoadMovie(MovieFull movie)
 {
     Movie = movie;
     MovieSettings.LoadMovie(Movie);
 }
예제 #10
0
 /// <summary>
 /// Initialize a new instance of DownloadMovieMessage class
 /// </summary>
 /// <param name="movie">The movie to download</param>
 public DownloadMovieMessage(MovieFull movie)
 {
     Movie = movie;
 }
예제 #11
0
        /// <summary>
        /// Translate movie informations (title, description, ...)
        /// </summary>
        /// <param name="movieToTranslate">Movie to translate</param>
        /// <param name="ct">Used to cancel translation</param>
        /// <returns>Task</returns>
        public async Task TranslateMovieFullAsync(MovieFull movieToTranslate, CancellationToken ct)
        {
            var watch = Stopwatch.StartNew();

            try
            {
                await Task.Run(async () =>
                {
                    var movie = await TmdbClient.GetMovieAsync(movieToTranslate.ImdbCode,
                        MovieMethods.Credits);
                    movieToTranslate.Title = movie?.Title;
                    movieToTranslate.Genres = movie?.Genres?.Select(a => a.Name).ToList();
                    movieToTranslate.DescriptionFull = movie?.Overview;
                }, ct);
            }
            catch (Exception exception) when (exception is TaskCanceledException)
            {
                Logger.Debug(
                    "TranslateMovieFull cancelled.");
            }
            catch (Exception exception)
            {
                Logger.Error(
                    $"TranslateMovieFull: {exception.Message}");
                throw;
            }
            finally
            {
                watch.Stop();
                var elapsedMs = watch.ElapsedMilliseconds;
                Logger.Debug(
                    $"TranslateMovieFull ({movieToTranslate.ImdbCode}) in {elapsedMs} milliseconds.");
            }
        }
예제 #12
0
        /// <summary>
        /// Download actors' image for a movie
        /// </summary>
        /// <param name="movie">The movie to process</param>
        /// <param name="ct">Used to cancel downloading actor image</param>
        public async Task DownloadCastImageAsync(MovieFull movie, CancellationTokenSource ct)
        {
            if (movie.Cast == null)
                return;

            var watch = Stopwatch.StartNew();

            try
            {
                await
                    movie.Cast.ForEachAsync(
                        cast =>
                            DownloadFileHelper.DownloadFileTaskAsync(cast.SmallImage,
                                Constants.CastMovieDirectory + cast.Name + Constants.ImageFileExtension, ct: ct),
                        (cast, t) =>
                        {
                            if (t.Item3 == null && !string.IsNullOrEmpty(t.Item2))
                                cast.SmallImagePath = t.Item2;
                        });
            }
            catch (Exception exception) when (exception is TaskCanceledException)
            {
                Logger.Debug(
                    "DownloadCastImageAsync cancelled.");
            }
            catch (Exception exception)
            {
                Logger.Error(
                    $"DownloadCastImageAsync: {exception.Message}");
                throw;
            }
            finally
            {
                watch.Stop();
                var elapsedMs = watch.ElapsedMilliseconds;
                Logger.Debug(
                    $"DownloadCastImageAsync ({movie.ImdbCode}) in {elapsedMs} milliseconds.");
            }
        }
예제 #13
0
        /// <summary>
        /// Download the movie's poster image
        /// </summary>
        /// <param name="movie">The movie to process</param>
        /// <param name="ct">Used to cancel downloading poster image</param>
        public async Task DownloadPosterImageAsync(MovieFull movie, CancellationTokenSource ct)
        {

            var watch = Stopwatch.StartNew();

            var posterPath = new List<string>
            {
                movie.LargeCoverImage
            };

            try
            {
                await
                    posterPath.ForEachAsync(
                        poster =>
                            DownloadFileHelper.DownloadFileTaskAsync(poster,
                                Constants.PosterMovieDirectory + movie.ImdbCode + Constants.ImageFileExtension, ct: ct),
                        (poster, t) =>
                        {
                            if (t.Item3 == null && !string.IsNullOrEmpty(t.Item2))
                                movie.LargeCoverImage = t.Item2;
                        });
            }
            catch (Exception exception) when (exception is TaskCanceledException)
            {
                Logger.Debug(
                    "DownloadPosterImageAsync cancelled.");
            }
            catch (Exception exception)
            {
                Logger.Error(
                    $"DownloadPosterImageAsync: {exception.Message}");
                throw;
            }
            finally
            {
                watch.Stop();
                var elapsedMs = watch.ElapsedMilliseconds;
                Logger.Debug(
                    $"DownloadPosterImageAsync ({movie.ImdbCode}) in {elapsedMs} milliseconds.");
            }
        }
예제 #14
0
        /// <summary>
        /// Download the movie's background image
        /// </summary>
        /// <param name="movie">The movie to process</param>
        /// <param name="ct">Used to cancel downloading background image</param>
        public async Task DownloadBackgroundImageAsync(MovieFull movie, CancellationTokenSource ct)
        {
            var watch = Stopwatch.StartNew();

            try
            {
                await Task.Run(async () =>
                {
                    TmdbClient.GetConfig();
                    var tmdbMovie = await TmdbClient.GetMovieAsync(movie.ImdbCode, MovieMethods.Images);
                    var remotePath = new List<string>
                    {
                        TmdbClient.GetImageUrl(Constants.BackgroundImageSizeTmDb,
                            tmdbMovie.BackdropPath).AbsoluteUri
                    };

                    await
                        remotePath.ForEachAsync(
                            background =>
                                DownloadFileHelper.DownloadFileTaskAsync(background,
                                    Constants.BackgroundMovieDirectory + movie.ImdbCode + Constants.ImageFileExtension,
                                    ct: ct),
                            (background, t) =>
                            {
                                if (t.Item3 == null && !string.IsNullOrEmpty(t.Item2))
                                    movie.BackgroundImagePath = t.Item2;
                            });
                }, ct.Token);
            }
            catch (Exception exception) when (exception is TaskCanceledException)
            {
                Logger.Debug(
                    "DownloadBackgroundImageAsync cancelled.");
            }
            catch (Exception exception)
            {
                Logger.Error(
                    $"DownloadBackgroundImageAsync: {exception.Message}");
                throw;
            }
            finally
            {
                watch.Stop();
                var elapsedMs = watch.ElapsedMilliseconds;
                Logger.Debug(
                    $"DownloadBackgroundImageAsync ({movie.ImdbCode}) in {elapsedMs} milliseconds.");
            }
        }
예제 #15
0
        /// <summary>
        /// Download a subtitle
        /// </summary>
        /// <param name="movie">The movie of which to retrieve its subtitles</param>
        /// <param name="progress">Report the progress of the download</param>
        /// <param name="ct">Cancellation token</param>
        public async Task DownloadSubtitleAsync(MovieFull movie, IProgress<long> progress, CancellationTokenSource ct)
        {
            if (movie.SelectedSubtitle == null)
                return;

            var watch = Stopwatch.StartNew();

            var filePath = Constants.Subtitles + movie.ImdbCode + "\\" + movie.SelectedSubtitle.Language.EnglishName +
                           ".zip";

            try
            {
                var result = await
                    DownloadFileHelper.DownloadFileTaskAsync(
                        Constants.YifySubtitles + movie.SelectedSubtitle.Url, filePath, progress: progress, ct: ct);

                if (result.Item3 == null && !string.IsNullOrEmpty(result.Item2))
                {
                    using (var archive = ZipFile.OpenRead(result.Item2))
                    {
                        foreach (var entry in archive.Entries)
                        {
                            if (entry.FullName.StartsWith("_") ||
                                !entry.FullName.EndsWith(".srt", StringComparison.OrdinalIgnoreCase)) continue;
                            var subtitlePath = Path.Combine(Constants.Subtitles + movie.ImdbCode,
                                entry.FullName);
                            if (!File.Exists(subtitlePath))
                                entry.ExtractToFile(subtitlePath);

                            movie.SelectedSubtitle.FilePath = subtitlePath;
                        }
                    }
                }
            }
            catch (Exception exception) when (exception is TaskCanceledException)
            {
                Logger.Debug(
                    "DownloadSubtitleAsync cancelled.");
            }
            catch (Exception exception)
            {
                Logger.Error(
                    $"DownloadSubtitleAsync: {exception.Message}");
                throw;
            }
            finally
            {
                watch.Stop();
                var elapsedMs = watch.ElapsedMilliseconds;
                Logger.Debug(
                    $"DownloadSubtitleAsync ({movie.ImdbCode}) in {elapsedMs} milliseconds.");
            }
        }
예제 #16
0
        /// <summary>
        /// Get the movie's subtitles according to a language
        /// </summary>
        /// <param name="movie">The movie of which to retrieve its subtitles</param>
        /// <param name="ct">Cancellation token</param>
        public async Task LoadSubtitlesAsync(MovieFull movie,
            CancellationToken ct)
        {
            var watch = Stopwatch.StartNew();

            var restClient = new RestClient(Constants.YifySubtitlesApi);
            var request = new RestRequest("/{segment}", Method.GET);
            request.AddUrlSegment("segment", movie.ImdbCode);

            try
            {
                var response = await restClient.ExecuteGetTaskAsync<SubtitlesWrapper>(request, ct);
                if (response.ErrorException != null)
                    throw response.ErrorException;

                var wrapper = response.Data;

                var subtitles = new ObservableCollection<Subtitle>();
                Dictionary<string, List<Subtitle>> movieSubtitles;
                if (wrapper.Subtitles == null)
                {
                    await Task.CompletedTask;
                    return;
                }
                if (wrapper.Subtitles.TryGetValue(movie.ImdbCode, out movieSubtitles))
                {
                    foreach (var subtitle in movieSubtitles)
                    {
                        var sub = subtitle.Value.Aggregate((sub1, sub2) => sub1.Rating > sub2.Rating ? sub1 : sub2);
                        subtitles.Add(new Subtitle
                        {
                            Id = sub.Id,
                            Language = new CustomLanguage
                            {
                                Culture = string.Empty,
                                EnglishName = subtitle.Key,
                                LocalizedName = string.Empty
                            },
                            Hi = sub.Hi,
                            Rating = sub.Rating,
                            Url = sub.Url
                        });
                    }
                }

                subtitles.Sort();
                movie.AvailableSubtitles = subtitles;
            }
            catch (Exception exception) when (exception is TaskCanceledException)
            {
                Logger.Debug(
                    "LoadSubtitlesAsync cancelled.");
            }
            catch (Exception exception)
            {
                Logger.Error(
                    $"LoadSubtitlesAsync: {exception.Message}");
                throw;
            }
            finally
            {
                watch.Stop();
                var elapsedMs = watch.ElapsedMilliseconds;
                Logger.Debug(
                    $"LoadSubtitlesAsync ({movie.ImdbCode}) in {elapsedMs} milliseconds.");
            }
        }
예제 #17
0
        /// <summary>
        /// Get the link to the youtube trailer of a movie
        /// </summary>
        /// <param name="movie">The movie</param>
        /// <param name="ct">Used to cancel loading trailer</param>
        /// <returns>Video trailer</returns>
        public async Task<ResultContainer<Video>> GetMovieTrailerAsync(MovieFull movie, CancellationToken ct)
        {
            var watch = Stopwatch.StartNew();

            var trailers = new ResultContainer<Video>();
            try
            {
                await Task.Run(async () => trailers = (await TmdbClient.GetMovieAsync(movie.ImdbCode, MovieMethods.Videos))?.Videos, ct);
            }
            catch (Exception exception) when (exception is TaskCanceledException)
            {
                Logger.Debug(
                    "GetMovieTrailerAsync cancelled.");
            }
            catch (Exception exception)
            {
                Logger.Error(
                    $"GetMovieTrailerAsync: {exception.Message}");
                throw;
            }
            finally
            {
                watch.Stop();
                var elapsedMs = watch.ElapsedMilliseconds;
                Logger.Debug(
                    $"GetMovieTrailerAsync ({movie.ImdbCode}) in {elapsedMs} milliseconds.");
            }

            return trailers;
        }
예제 #18
0
 /// <summary>
 /// Initialize a new instance of PlayMovieMessage class
 /// </summary>
 /// <param name="movie">The movie</param>
 public PlayMovieMessage(MovieFull movie)
 {
     Movie = movie;
 }
예제 #19
0
        /// <summary>
        /// Load movie's trailer asynchronously
        /// </summary>
        /// <param name="movie">The movie</param>
        /// <param name="ct">Cancellation token</param>
        public async Task LoadTrailerAsync(MovieFull movie, CancellationToken ct)
        {
            try
            {
                var trailer = await _movieService.GetMovieTrailerAsync(movie, ct);

                var video =
                    await
                        GetVideoInfoForStreamingAsync(
                            Constants.YoutubePath + trailer.Results.FirstOrDefault()?.Key,
                            Constants.YoutubeStreamingQuality.High);

                if (video != null && video.RequiresDecryption)
                {
                    Logger.Info(
                        $"Decrypting Youtube trailer url: {video.Title}");
                    await Task.Run(() => DownloadUrlResolver.DecryptDownloadUrl(video), ct);
                }

                if (video == null)
                {
                    Logger.Error(
                        $"Failed loading movie's trailer: {movie.Title}");
                    Messenger.Default.Send(
                        new ManageExceptionMessage(
                            new Exception(
                                LocalizationProviderHelper.GetLocalizedValue<string>("TrailerNotAvailable"))));
                    Messenger.Default.Send(new StopPlayingTrailerMessage());
                    return;
                }

                if (!ct.IsCancellationRequested)
                {
                    Logger.Debug(
                        $"Movie's trailer loaded: {movie.Title}");
                    TrailerPlayer = new TrailerPlayerViewModel(_applicationState, _movieService, _movieHistoryService);
                    TrailerPlayer.LoadTrailer(new Models.Trailer.Trailer(new Uri(video.DownloadUrl)));
                }
            }
            catch (Exception exception) when (exception is TaskCanceledException)
            {
                Logger.Debug(
                    "GetMovieTrailerAsync cancelled.");
                Messenger.Default.Send(new StopPlayingTrailerMessage());
            }
            catch (Exception exception) when (exception is SocketException || exception is WebException)
            {
                Logger.Error(
                    $"GetMovieTrailerAsync: {exception.Message}");
                Messenger.Default.Send(new StopPlayingTrailerMessage());
                Messenger.Default.Send(new ManageExceptionMessage(exception));
            }
            catch (Exception exception)
                when (exception is VideoNotAvailableException || exception is YoutubeParseException)
            {
                Logger.Error(
                    $"GetMovieTrailerAsync: {exception.Message}");
                Messenger.Default.Send(
                    new ManageExceptionMessage(
                        new Exception(
                            LocalizationProviderHelper.GetLocalizedValue<string>(
                                "TrailerNotAvailable"))));
                Messenger.Default.Send(new StopPlayingTrailerMessage());
            }
            catch (Exception exception)
            {
                Logger.Error(
                    $"GetMovieTrailerAsync: {exception.Message}");
                Messenger.Default.Send(new StopPlayingTrailerMessage());
            }
        }
예제 #20
0
        /// <summary>
        /// Get TMDb movie informations
        /// </summary>
        /// <param name="movieToLoad">Movie to load</param>
        /// <param name="ct">Used to cancel loading</param>
        /// <returns>Movie's full details</returns>
        public async Task<MovieFull> GetMovieFullDetailsAsync(MovieShort movieToLoad, CancellationToken ct)
        {
            var watch = Stopwatch.StartNew();

            var movie = new MovieFull();

            var restClient = new RestClient(Constants.YtsApiEndpoint);
            var request = new RestRequest("/{segment}", Method.GET);
            request.AddUrlSegment("segment", "movie_details.json");
            request.AddParameter("movie_id", movieToLoad.Id);
            request.AddParameter("with_images", "true");
            request.AddParameter("with_cast", "true");

            try
            {
                var response = await restClient.ExecuteGetTaskAsync<WrapperMovieFull>(request, ct);
                if (response.ErrorException != null)
                    throw response.ErrorException;

                await Task.Run(async () =>
                {
                    var tmdbInfos = await TmdbClient.GetMovieAsync(response.Data.Data.Movie.ImdbCode,
                        MovieMethods.Credits);

                    movie = new MovieFull
                    {
                        Id = response.Data.Data.Movie.Id,
                        Cast = response.Data.Data.Movie.Cast,
                        BackgroundImagePath = string.Empty,
                        DateUploaded = response.Data.Data.Movie.DateUploaded,
                        DateUploadedUnix = response.Data.Data.Movie.DateUploadedUnix,
                        DescriptionFull = tmdbInfos.Overview,
                        DescriptionIntro = response.Data.Data.Movie.DescriptionIntro,
                        DownloadCount = response.Data.Data.Movie.DownloadCount,
                        FullHdAvailable = response.Data.Data.Movie.Torrents.Any(torrent => torrent.Quality == "1080p"),
                        Genres = tmdbInfos.Genres.Select(a => a.Name).ToList(),
                        ImdbCode = response.Data.Data.Movie.ImdbCode,
                        Language = response.Data.Data.Movie.Language,
                        LikeCount = response.Data.Data.Movie.LikeCount,
                        MpaRating = response.Data.Data.Movie.MpaRating,
                        LargeCoverImage = response.Data.Data.Movie.LargeCoverImage,
                        PosterImagePath = string.Empty,
                        RatingValue = response.Data.Data.Movie.Rating,
                        RtAudienceRating = response.Data.Data.Movie.RtAudienceRating,
                        RtAudienceScore = response.Data.Data.Movie.RtAudienceScore,
                        RtCriticsRating = response.Data.Data.Movie.RtCriticsRating,
                        RtCrtiticsScore = response.Data.Data.Movie.RtCrtiticsScore,
                        Runtime = response.Data.Data.Movie.Runtime,
                        Title = tmdbInfos.Title,
                        TitleLong = response.Data.Data.Movie.TitleLong,
                        Torrents = response.Data.Data.Movie.Torrents,
                        Url = response.Data.Data.Movie.Url,
                        WatchInFullHdQuality = false,
                        Year = response.Data.Data.Movie.Year,
                        YtTrailerCode = response.Data.Data.Movie.YtTrailerCode
                    };
                }, ct);
            }
            catch (Exception exception) when (exception is TaskCanceledException)
            {
                Logger.Debug(
                    "GetMovieFullDetailsAsync cancelled.");
            }
            catch (Exception exception)
            {
                Logger.Error(
                    $"GetMovieFullDetailsAsync: {exception.Message}");
                throw;
            }
            finally
            {
                watch.Stop();
                var elapsedMs = watch.ElapsedMilliseconds;
                Logger.Debug(
                    $"GetMovieFullDetailsAsync ({movie.ImdbCode}) in {elapsedMs} milliseconds.");
            }

            return movie;
        }
예제 #21
0
        public void GetHashCode_DifferentMovies_ReturnsDifferentHashCode()
        {
            var fixture = new Fixture();

            var id1 = fixture.Create<int>();
            var dateUploadedUnix1 = fixture.Create<int>();

            var id2 = fixture.Create<int>();
            var dateUploadedUnix2 = fixture.Create<int>();

            var movie1 = new MovieFull
            {
                Id = id1,
                DateUploadedUnix = dateUploadedUnix1
            };

            var movie2 = new MovieFull
            {
                Id = id2,
                DateUploadedUnix = dateUploadedUnix2
            };

            Assert.AreNotEqual(
                _comparer.GetHashCode(movie1), _comparer.GetHashCode(movie2));
        }
 /// <summary>
 /// Load a movie
 /// </summary>
 /// <param name="movie"></param>
 public void LoadMovie(MovieFull movie)
 {
     Movie = movie;
 }