public async Task Movie_Has_Custom_Url_When_Specified_In_Settings() { SettingsMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(new JellyfinSettings { Enable = true, Servers = new List <JellyfinServers> { new JellyfinServers { ServerHostname = "http://test.com/", ServerId = "8" } } }); ContextMock.Setup(x => x.GetByTheMovieDbId(It.IsAny <string>())).ReturnsAsync(new JellyfinContent { ProviderId = "123", JellyfinId = 1.ToString(), }); var search = new SearchMovieViewModel() { TheMovieDbId = "123", }; var result = await Rule.Execute(search); Assert.True(result.Success); Assert.That(search.JellyfinUrl, Is.EqualTo("http://test.com/web/index.html#!/details?id=1&serverId=8")); }
public async Task CallMovieServiceOnce_OnGet() { // Arrange var movieServiceMock = new Mock <IMovieService>(); var genreServiceMock = new Mock <IGenreService>(); string searchTerm = "hello"; movieServiceMock .Setup(g => g.SearchAsync(searchTerm)) .ReturnsAsync(new List <MovieViewModel>()); var sut = new MovieController(movieServiceMock.Object, genreServiceMock.Object); var searchModel = new SearchMovieViewModel() { SearchName = searchTerm }; // Act await sut.Search(searchModel); // Assert movieServiceMock.Verify(g => g.SearchAsync(searchTerm), Times.Once); }
private async Task CheckForSubscription(SearchMovieViewModel viewModel) { // Check if this user requested it var user = await GetUser(); if (user == null) { return; } var request = await RequestService.MovieRequestService.GetAll() .AnyAsync(x => x.RequestedUserId.Equals(user.Id) && x.TheMovieDbId == viewModel.Id); if (request || viewModel.Available) { viewModel.ShowSubscribe = false; } else { viewModel.ShowSubscribe = true; var sub = await _subscriptionRepository.GetAll().FirstOrDefaultAsync(s => s.UserId == user.Id && s.RequestId == viewModel.RequestId && s.RequestType == RequestType.Movie); viewModel.Subscribed = sub != null; } }
public async Task Movie_Uses_Default_Url_When() { SettingsMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(new EmbySettings { Enable = true, Servers = new List <EmbyServers> { new EmbyServers { ServerHostname = string.Empty, ServerId = "8" } } }); ContextMock.Setup(x => x.GetByTheMovieDbId(It.IsAny <string>())).ReturnsAsync(new EmbyContent { ProviderId = "123", EmbyId = 1.ToString() }); var search = new SearchMovieViewModel() { TheMovieDbId = "123", }; var result = await Rule.Execute(search); Assert.True(result.Success); Assert.That(search.EmbyUrl, Is.EqualTo("https://app.emby.media/web/index.html#!/item?id=1&serverId=8")); }
public ActionResult SearchResultsMovies(SearchMovieViewModel smvm) { VarGlobal.SearchMovieName = smvm.Name; VarGlobal.SearchMovieGenre = smvm.Genre; return(View(new SearchResultsMovieViewModel())); }
/// <summary> /// Initializes a new instance of the MainViewModel class. /// </summary> /// <param name="movieService">Instance of MovieService</param> /// <param name="userService">Instance of UserService</param> /// <param name="applicationService">Instance of ApplicationService</param> /// <param name="genreService">The genre service</param> public MoviePageViewModel(IMovieService movieService, IUserService userService, IApplicationService applicationService, IGenreService genreService) { _movieService = movieService; _userService = userService; ApplicationService = applicationService; GenreViewModel = new GenreViewModel(userService, genreService); RegisterMessages(); RegisterCommands(); Search = new SearchMovieViewModel(); DispatcherHelper.CheckBeginInvokeOnUI(async() => { Tabs.Add(new PopularMovieTabViewModel(ApplicationService, _movieService, _userService)); Tabs.Add(new GreatestMovieTabViewModel(ApplicationService, _movieService, _userService)); Tabs.Add(new RecentMovieTabViewModel(ApplicationService, _movieService, _userService)); Tabs.Add(new FavoritesMovieTabViewModel(ApplicationService, _movieService, _userService)); Tabs.Add(new SeenMovieTabViewModel(ApplicationService, _movieService, _userService)); SelectedTab = Tabs.First(); SelectedMoviesIndexMenuTab = 0; await GenreViewModel.LoadGenresAsync().ConfigureAwait(false); await Tabs.ToList().ParallelForEachAsync(async tab => { await tab.LoadMoviesAsync().ConfigureAwait(false); }).ConfigureAwait(false); }); }
/// <summary> /// Initializes a new instance of the MainViewModel class. /// </summary> /// <param name="movieService">Instance of MovieService</param> /// <param name="movieHistoryService">Instance of MovieHistoryService</param> /// <param name="applicationService">Instance of ApplicationService</param> public MoviePageViewModel(IMovieService movieService, IMovieHistoryService movieHistoryService, IApplicationService applicationService) { _movieService = movieService; _movieHistoryService = movieHistoryService; ApplicationService = applicationService; GenresMovie = new GenresMovieViewModel(_movieService); RegisterMessages(); RegisterCommands(); Search = new SearchMovieViewModel(); DispatcherHelper.CheckBeginInvokeOnUI(async() => { Tabs.Add(new PopularMovieTabViewModel(ApplicationService, _movieService, _movieHistoryService)); Tabs.Add(new GreatestMovieTabViewModel(ApplicationService, _movieService, _movieHistoryService)); Tabs.Add(new RecentMovieTabViewModel(ApplicationService, _movieService, _movieHistoryService)); Tabs.Add(new FavoritesMovieTabViewModel(ApplicationService, _movieService, _movieHistoryService)); Tabs.Add(new SeenMovieTabViewModel(ApplicationService, _movieService, _movieHistoryService)); SelectedTab = Tabs.First(); SelectedMoviesIndexMenuTab = 0; var loadMoviesTask = Tabs.ParallelForEachAsync(async tab => { await tab.LoadMoviesAsync(); }); var loadGenreTask = GenresMovie.LoadGenresAsync(); await Task.WhenAll(new List <Task> { loadMoviesTask, loadGenreTask }); }); }
public async Task Movie_Uses_Default_Url_When() { SettingsMock.Setup(x => x.GetSettingsAsync()).ReturnsAsync(new JellyfinSettings { Enable = true, Servers = new List <JellyfinServers> { new JellyfinServers { Ip = "8080", Port = 9090, ServerHostname = string.Empty, ServerId = "8" } } }); ContextMock.Setup(x => x.GetByTheMovieDbId(It.IsAny <string>())).ReturnsAsync(new JellyfinContent { ProviderId = "123", JellyfinId = 1.ToString() }); var search = new SearchMovieViewModel() { TheMovieDbId = "123", }; var result = await Rule.Execute(search); Assert.True(result.Success); }
private async Task <SearchMovieViewModel> ProcessSingleMovie(SearchMovieViewModel viewMovie) { if (viewMovie.ImdbId.IsNullOrEmpty()) { var showInfo = await Cache.GetOrAddAsync("GetMovieInformationWIthImdbId" + viewMovie.Id, () => MovieApi.GetMovieInformation(viewMovie.Id), DateTimeOffset.Now.AddHours(12)); viewMovie.Id = showInfo.Id; // TheMovieDbId viewMovie.ImdbId = showInfo.ImdbId; } var user = await GetUser(); var digitalReleaseDate = viewMovie.ReleaseDates?.Results?.FirstOrDefault(x => x.IsoCode == user.StreamingCountry); if (digitalReleaseDate == null) { digitalReleaseDate = viewMovie.ReleaseDates?.Results?.FirstOrDefault(x => x.IsoCode == "US"); } viewMovie.DigitalReleaseDate = digitalReleaseDate?.ReleaseDate?.FirstOrDefault(x => x.Type == ReleaseDateType.Digital)?.ReleaseDate; viewMovie.TheMovieDbId = viewMovie.Id.ToString(); await RunSearchRules(viewMovie); // This requires the rules to be run first to populate the RequestId property await CheckForSubscription(viewMovie); return(viewMovie); }
public IActionResult Search(SearchMovieViewModel vm) { // TODO - Show what filters have been applied. // List<Film> films = new List<Film>(); // Gets films matching the search value and filter (if selected). List <Film> films = _filmServices.GetAllCompleteFilms() .WhereIf(!string.IsNullOrEmpty(vm.MediaFilter), f => f.Media.Name == vm.MediaFilter) .WhereIf(!string.IsNullOrEmpty(vm.SearchValue), f => f.Name.ToLower().Contains(vm.SearchValue.ToLower())) .WhereIf(!string.IsNullOrEmpty(vm.AudioFilter), f => f.Audio.Name == vm.AudioFilter) .WhereIf(!string.IsNullOrEmpty(vm.GenreFilter), f => f.FilmGenres.Any(fg => fg.Genre != null && fg.Genre.Name == vm.GenreFilter)) .ToList(); // Filter out films that should not be visible to the User based on privacy level films = _filmServices.GetAllVisible(films, User); // sort the collection of films by selected value (title ascending is default) vm.Films = _filmServices.SortBy(films, vm.SortPriority); // TODO - Check if Genres needs the full Genre models or just the Ids vm.Genres = _context.Genres.ToList(); vm.MediaFormats = _context.MediaFormats.ToList(); vm.AudioFormats = _context.AudioFormats.ToList(); // TODO - Add pagination for the results. See WebSearch. return(View(vm)); }
public async Task ReturnCorrectViewModel_OnGet() { // Arrange var movieServiceMock = new Mock <IMovieService>(); var genreServiceMock = new Mock <IGenreService>(); string searchTerm = "hello"; movieServiceMock .Setup(g => g.SearchAsync(searchTerm)) .ReturnsAsync(new List <MovieViewModel>()); var sut = new MovieController(movieServiceMock.Object, genreServiceMock.Object); var searchModel = new SearchMovieViewModel() { SearchName = searchTerm }; // Act var result = await sut.Search(searchModel) as ViewResult; // Assert Assert.IsInstanceOfType(result.Model, typeof(SearchMovieViewModel)); }
public async Task Movie_ShouldBe_NotAvailable_WhenNotFoundInJellyfin() { ContextMock.Setup(x => x.GetByTheMovieDbId(It.IsAny <string>())).Returns(Task.FromResult(default(JellyfinContent))); var search = new SearchMovieViewModel(); var result = await Rule.Execute(search); Assert.True(result.Success); Assert.False(search.Available); }
public async Task ShouldBe_NotAvailable_WhenNotFoundInPlex() { ContextMock.Setup(x => x.Get(It.IsAny<string>())).Returns(Task.FromResult(default(PlexServerContent))); var search = new SearchMovieViewModel(); var result = await Rule.Execute(search); Assert.True(result.Success); Assert.Null(search.PlexUrl); Assert.False(search.Available); }
public async Task <IActionResult> Search(SearchMovieViewModel model) { if (string.IsNullOrEmpty(model.SearchName)) { return(this.View()); } var movies = await this.movieService.SearchAsync(model.SearchName); model.Movies = movies; return(this.View(model)); }
public ActionResult ComingSoon() { ViewBag.viewheadline = "Coming Soon on DVD/Blu-ray"; ViewBag.comingSoon = "active-menu"; ViewBag.dropDownState = "Movies"; var repo = new MovieGalleryRepository(); var movieRepo = repo.MoviesComingSoon(); var viewModel = new SearchMovieViewModel <MovieSearchItems>(repo, movieRepo.MovieItems, movieRepo.page, movieRepo.total_pages, movieRepo.total_results); return(View("~/Views/MovieGallery/Index.cshtml", viewModel)); }
public ActionResult Index() { ViewBag.viewheadline = "DVD/Blu-ray News"; ViewBag.currentNews = "active-menu"; ViewBag.dropDownState = "Movies"; var repo = new MovieGalleryRepository(); var movieRepo = repo.GetRecentReleasedMovies(); var viewModel = new SearchMovieViewModel <MovieSearchItems>(repo, movieRepo.MovieItems, movieRepo.page, movieRepo.total_pages, movieRepo.total_results); return(View("~/Views/MovieGallery/Index.cshtml", viewModel)); }
public async Task Movie_ShouldBe_Available_WhenFoundInEmby() { ContextMock.Setup(x => x.GetByTheMovieDbId(It.IsAny <string>())).ReturnsAsync(new EmbyContent { ProviderId = "123" }); var search = new SearchMovieViewModel(); var result = await Rule.Execute(search); Assert.True(result.Success); Assert.True(search.Available); }
public async Task Movie_Uses_Default_Url_When() { ContextMock.Setup(x => x.GetByTheMovieDbId(It.IsAny <string>())).ReturnsAsync(new JellyfinContent { TheMovieDbId = "123", JellyfinId = 1.ToString() }); var search = new SearchMovieViewModel() { TheMovieDbId = "123", }; var result = await Rule.Execute(search); Assert.True(result.Success); }
private async Task <SearchMovieViewModel> ProcessSingleMovie(SearchMovieViewModel viewMovie, bool lookupExtraInfo = false) { if (lookupExtraInfo) { var showInfo = await MovieApi.GetMovieInformation(viewMovie.Id); viewMovie.Id = showInfo.Id; // TheMovieDbId viewMovie.ImdbId = showInfo.ImdbId; } viewMovie.TheMovieDbId = viewMovie.Id.ToString(); await RunSearchRules(viewMovie); return(viewMovie); }
public async Task Movie_ShouldBe_Available_WhenFoundInJellyfin() { ContextMock.Setup(x => x.GetByTheMovieDbId(It.IsAny <string>())).ReturnsAsync(new JellyfinContent { TheMovieDbId = "123", Quality = "1080" }); var search = new SearchMovieViewModel() { TheMovieDbId = "123", }; var result = await Rule.Execute(search); Assert.True(result.Success); Assert.True(search.Available); }
public IActionResult Search(string query) { List <Film> films = _context.Films .Include(f => f.User) .Where(f => f.Name.ToLower().Contains(query.ToLower())) .Where(f => _filmServices.IsFilmViewable(f, User)) .ToList(); var vm = new SearchMovieViewModel(films); vm.Genres = _context.Genres.ToList(); vm.MediaFormats = _context.MediaFormats.ToList(); vm.AudioFormats = _context.AudioFormats.ToList(); return(View(vm)); }
public async Task Should_ReturnApproved_WhenMovieIsInCouchPotato() { var list = new CouchPotatoCache { TheMovieDbId = 123 }; ContextMock.Setup(x => x.FirstOrDefaultAsync(It.IsAny <Expression <Func <CouchPotatoCache, bool> > >())).ReturnsAsync(list); var request = new SearchMovieViewModel { Id = 123 }; var result = await Rule.Execute(request); Assert.True(result.Success); Assert.True(request.Approved); }
public async Task Should_ReturnNotApproved_WhenMovieIsNotInRadarr() { var list = DbHelper.GetQueryableMockDbSet(new RadarrCache { TheMovieDbId = 000012, }); ContextMock.Setup(x => x.GetAll()).Returns(list); var request = new SearchMovieViewModel { Id = 123 }; var result = await Rule.Execute(request); Assert.True(result.Success); Assert.False(request.Approved); }
public async Task <IActionResult> Search(SearchMovieViewModel model) { var jsonResult = await this.client.SearchMovie(model.SearchString); try { var apiMoviesFound = this.jsonProvider.ExtractFoundMoviesFromSearchMovieJsonResult(jsonResult); model.ApiMovies = apiMoviesFound.Select(m => new MovieViewModel(m)); var dbMoviesFound = this.movieService.SearchMovie(model.SearchString); model.DbMovies = dbMoviesFound.Select(m => new MovieViewModel(m));; } catch (InvalidOperationException) { } return(View(model)); }
public async Task ShouldBe_Available_WhenFoundInPlex() { ContextMock.Setup(x => x.Get(It.IsAny<string>())).ReturnsAsync(new PlexServerContent { Url = "TestUrl", ImdbId = "132" }); var search = new SearchMovieViewModel { ImdbId = "123", }; var result = await Rule.Execute(search); Assert.True(result.Success); Assert.AreEqual("TestUrl", search.PlexUrl); Assert.True(search.Available); }
public async Task Movie_ShouldBe_Available_WhenFoundInJellyfin_4K() { FeatureMock.Setup(x => x.FeatureEnabled(FeatureNames.Movie4KRequests)).ReturnsAsync(true); ContextMock.Setup(x => x.GetByTheMovieDbId(It.IsAny <string>())).ReturnsAsync(new JellyfinContent { TheMovieDbId = "123", Has4K = true }); var search = new SearchMovieViewModel() { TheMovieDbId = "123", }; var result = await Rule.Execute(search); Assert.True(result.Success); Assert.False(search.Available); Assert.True(search.Available4K); }
private async Task <SearchMovieViewModel> ProcessSingleMovie(SearchMovieViewModel viewMovie, bool lookupExtraInfo = false) { if (lookupExtraInfo) { var showInfo = await MovieApi.GetMovieInformation(viewMovie.Id); viewMovie.Id = showInfo.Id; // TheMovieDbId viewMovie.ImdbId = showInfo.ImdbId; var usDates = viewMovie.ReleaseDates?.Results?.FirstOrDefault(x => x.IsoCode == "US"); viewMovie.DigitalReleaseDate = usDates?.ReleaseDate?.FirstOrDefault(x => x.Type == ReleaseDateType.Digital)?.ReleaseDate; } viewMovie.TheMovieDbId = viewMovie.Id.ToString(); await RunSearchRules(viewMovie); return(viewMovie); }
/// <summary> /// Initializes a new instance of the MainViewModel class. /// </summary> /// <param name="movieService">Instance of MovieService</param> /// <param name="userService">Instance of UserService</param> /// <param name="applicationService">Instance of ApplicationService</param> /// <param name="genreService">The genre service</param> public MoviePageViewModel(IMovieService movieService, IUserService userService, IApplicationService applicationService, IGenreService genreService) { MovieService = movieService; UserService = userService; ApplicationService = applicationService; GenreViewModel = new GenreViewModel(userService, genreService); RegisterMessages(); RegisterCommands(); Search = new SearchMovieViewModel(); Tabs.Add(new PopularMovieTabViewModel(ApplicationService, MovieService, UserService)); Tabs.Add(new GreatestMovieTabViewModel(ApplicationService, MovieService, UserService)); Tabs.Add(new RecentMovieTabViewModel(ApplicationService, MovieService, UserService)); Tabs.Add(new FavoritesMovieTabViewModel(ApplicationService, MovieService, UserService)); Tabs.Add(new SeenMovieTabViewModel(ApplicationService, MovieService, UserService)); SelectedTab = Tabs.First(); SelectedMoviesIndexMenuTab = 0; }
public async Task ShouldBe_NotRequested_WhenNewMovie() { var list = new MovieRequests { TheMovieDbId = 123, Approved = true }; MovieMock.Setup(x => x.GetRequestAsync(123)).ReturnsAsync(list); var search = new SearchMovieViewModel { Id = 999, }; var result = await Rule.Execute(search); Assert.True(result.Success); Assert.False(search.Approved); Assert.False(search.Requested); }
public async Task Should_ReturnApproved_WhenMovieIsInRadarr() { var list = new List <RadarrCache>() { new RadarrCache { TheMovieDbId = 123 } }.AsQueryable(); ContextMock.Setup(x => x.GetAll()).Returns(list); var request = new SearchMovieViewModel { Id = 123 }; var result = await Rule.Execute(request); Assert.True(result.Success); Assert.True(request.Approved); }