Пример #1
0
        private List <Movie> GetMoviesFromResponse(ApiSearchResponse <MovieInfo> response)
        {
            List <Movie> movies;


            if (response.Results != null)
            {
                movies = response.Results.Select(x => new Movie
                {
                    Title          = x.Title,
                    Year           = x.ReleaseDate.Year,
                    ImageRemote    = x.PosterPath,
                    BackdropRemote = x.BackdropPath,
                    Description    = x.Overview,
                    Id             = x.Id,
                    Genres         = x.Genres.Select(y => y.Name).ToList(),
                    AverageVote    = x.VoteAverage
                }).ToList();
                foreach (Movie m in movies)
                {
                    m.Actors  = new List <string>();;
                    m.Runtime = 0;
                }

                return(movies);
            }
            else
            {
                return(new List <Movie>());
            }
        }
 public MovieListController(ApiSearchResponse <MovieInfo> response, ImageDownloader downloader, IApiMovieRequest movieApi, MovieCredit[] credits)
 {
     this._response   = response;
     this._downloader = downloader;
     this._movieApi   = movieApi;
     this._credits    = credits;
 }
        private async Task GetTopRatedMovies()
        {
            var movieApi = MovieDbFactory.Create <IApiMovieRequest>().Value;
            ApiSearchResponse <MovieInfo> responseMovieInfos = await movieApi.GetTopRatedAsync();

            await _movieHelper.GetMovies(responseMovieInfos);

            _topMoviesList = _movieHelper.MoviesList;

            // Set image path
            StorageClient   client     = new StorageClient();
            ImageDownloader downloader = new ImageDownloader(client);

            foreach (Movie m in _movieHelper.MoviesList)
            {
                if (m.ImagePath != null)
                {
                    string localPath = downloader.LocalPathForFilename(m.ImagePath);

                    // if localPath does not exist then download image
                    if (!File.Exists(localPath))
                    {
                        await downloader.DownloadImage(m.ImagePath, localPath, new CancellationToken());
                    }

                    m.setImagePath(localPath);
                }
                else
                {
                    m.setImagePath("");
                }
            }
        }
Пример #4
0
        public async Task <List <Movie> > getListOfTopRatedMovies()
        {
            List <Movie> responseMovieList         = new List <Movie>();
            ApiSearchResponse <MovieInfo> response = await _movieApi.GetTopRatedAsync(1);

            foreach (MovieInfo info in response.Results)
            {
                ApiQueryResponse <MovieCredit> cast = await _movieApi.GetCreditsAsync(info.Id);

                List <string> actors = new List <string>();
                int           number = 3;
                if (cast.Item.CastMembers.Count < 3)
                {
                    number = cast.Item.CastMembers.Count;
                }
                for (int i = 0; i < number; i++)
                {
                    actors.Add(cast.Item.CastMembers[i].Name);
                }

                responseMovieList.Add(new Movie()
                {
                    Id = info.Id, Title = info.Title, Year = info.ReleaseDate, Actors = actors, ImageUrl = info.PosterPath
                });
            }

            return(responseMovieList);
        }
Пример #5
0
        private Movie GetMovieFromResponse(ApiSearchResponse <MovieInfo> response)
        {
            Movie movie;


            if (response.Results != null)
            {
                movie = response.Results.Select(x => new Movie
                {
                    Title          = x.Title,
                    Year           = x.ReleaseDate.Year,
                    ImageRemote    = x.PosterPath,
                    BackdropRemote = x.BackdropPath,
                    Description    = x.Overview,
                    Id             = x.Id,
                    Genres         = x.Genres.Select(y => y.Name).ToList(),
                    AverageVote    = x.VoteAverage
                }).FirstOrDefault();
                movie.Actors  = new List <string>();
                movie.Runtime = 0;

                return(movie);
            }
            else
            {
                return(new Movie());
            }
        }
Пример #6
0
        public async Task <List <Movie> > GetMoviesByTitle(string title)
        {
            ApiSearchResponse <MovieInfo> response = await _movieDbApi.SearchByTitleAsync(title);

            _movies = new List <Movie>();
            if (response.Results == null)
            {
                return(_movies);
            }

            foreach (MovieInfo movie in response.Results)
            {
                _movies.Add(new Movie
                {
                    Id             = movie.Id,
                    Title          = movie.Title,
                    ReleaseDate    = movie.ReleaseDate,
                    ReleaseYear    = movie.ReleaseDate.Year,
                    RemoteImageUrl = movie.PosterPath,
                    LocalImageUrl  = "",
                    Actors         = new List <String>(),
                    Rating         = movie.VoteAverage
                });
            }
            return(_movies);
        }
Пример #7
0
        public override async void ViewDidLoad()
        {
            base.ViewDidLoad();

            this.View.BackgroundColor = UIColor.FromRGB(0.714f, 0.98f, 1);
            this.Title = "Top Rated Movies";

            var spinner = new UIActivityIndicatorView(UIActivityIndicatorViewStyle.Gray);

            spinner.Frame = new CGRect(20, 10, this.View.Bounds.Width - 2 * 20, 50);
            this.View.AddSubview(spinner);
            spinner.StartAnimating();

            var movieApi = MovieDbFactory.Create <DM.MovieApi.MovieDb.Movies.IApiMovieRequest>().Value;
            ApiSearchResponse <MovieInfo> res = await movieApi.GetTopRatedAsync();

            foreach (var i in res.Results)
            {
                Movie movie = new Movie();
                await setMovieInfo.setInfo(i, movieApi, movie);

                this._movieList.Add(movie);
            }

            this.TableView.Source = new MovieListSource(this._movieList, OnSelectedMovie);

            spinner.StopAnimating();
            this.TableView.ReloadData();
        }
Пример #8
0
        public async Task <List <MovieListViewModel> > GetTopRatedMovies()
        {
            ApiSearchResponse <MovieInfo> response = await _movieDbApi.GetTopRatedAsync();

            List <MovieListViewModel> movies = new List <MovieListViewModel>();

            if (response.Results == null)
            {
                return(movies);
            }

            foreach (MovieInfo movie in response.Results)
            {
                movies.Add(new MovieListViewModel
                {
                    Id             = movie.Id,
                    Title          = movie.Title,
                    ReleaseDate    = movie.ReleaseDate,
                    ReleaseYear    = movie.ReleaseDate.Year,
                    RemoteImageUrl = movie.PosterPath,
                    LocalImageUrl  = "",
                    Actors         = new List <String>(),
                    Rating         = movie.VoteAverage
                });
            }
            return(movies);
        }
Пример #9
0
        public async Task <List <MovieDetails> > GetMovieByTitle(string title)
        {
            ApiSearchResponse <MovieInfo> response = await _api.SearchByTitleAsync(title);

            if (_movies == null)
            {
                _movies.Clear();
            }
            else
            {
                _movies = new List <MovieDetails>();
            }

            foreach (MovieInfo info in response.Results)
            {
                _movies.Add(new MovieDetails
                {
                    id             = info.Id,
                    title          = info.Title,
                    imageUrl       = info.PosterPath,
                    releaseDate    = info.ReleaseDate,
                    voteAverage    = info.VoteAverage,
                    voteCount      = info.VoteCount,
                    posterFilePath = "",
                    runtime        = "",
                    genres         = new List <String>(),
                    actors         = new List <String>()
                });
            }

            return(_movies);
        }
        public async Task SearchByNameAsync_Milla_Jovovich_Returns_SingleResult_WithExpectedValues()
        {
            const string millaJovovich = "Milla Jovovich";

            ApiSearchResponse <PersonInfo> response = await _api.SearchByNameAsync(millaJovovich);

            ApiResponseUtil.AssertErrorIsNull(response);

            Assert.AreEqual(1, response.TotalResults);
            Assert.AreEqual(1, response.Results.Count);

            PersonInfo person = response.Results.Single();

            Assert.AreEqual(PersonId_MillaJovovich, person.Id);
            Assert.AreEqual(millaJovovich, person.Name);
            Assert.IsFalse(person.IsAdultFilmStar);
            Assert.AreEqual(3, person.KnownFor.Count);

            string[] roles =
            {
                "The Fifth Element",
                "Resident Evil: Retribution",
                "Resident Evil",
            };

            foreach (string role in roles)
            {
                PersonInfoRole info = person.KnownFor.SingleOrDefault(x => x.MovieTitle == role);
                Assert.IsNotNull(info);
                Assert.AreEqual(MediaType.Movie, info.MediaType);
            }
        }
        public override void ViewDidLoad()
        {
            base.ViewDidLoad();
            this.Title = "Movie search";
            this.View.BackgroundColor = UIColor.FromRGB(245, 244, 244);

            this._yCoord = StartY;
            var prompt          = this.CreatePrompt();
            var movieField      = this.CreateMovieField();
            var getMoviesButton = this.CreateButton("Get movies");

            getMoviesButton.TouchUpInside += async(sender, args) =>
            {
                movieField.ResignFirstResponder();
                getMoviesButton.Enabled = false;

                activitySpinner.Frame            = new CGRect(HorizontalMargin, this._yCoord, this.View.Bounds.Width - 2 * HorizontalMargin, 50);
                activitySpinner.AutoresizingMask = UIViewAutoresizing.All;
                this.View.AddSubview(activitySpinner);
                activitySpinner.StartAnimating();

                // API call to get searched movies
                var movieApi = MovieDbFactory.Create <IApiMovieRequest>().Value;
                ApiSearchResponse <MovieInfo> responseMovieInfos = await movieApi.SearchByTitleAsync(movieField.Text == null? "" : movieField.Text);

                await _movieHelper.GetMovies(responseMovieInfos);

                // set imgpath
                StorageClient   client     = new StorageClient();
                ImageDownloader downloader = new ImageDownloader(client);
                foreach (Movie m in _movieHelper.MoviesList)
                {
                    if (m.ImagePath != null)
                    {
                        string localPath = downloader.LocalPathForFilename(m.ImagePath);

                        // if localPath does not exist then download image
                        if (!File.Exists(localPath))
                        {
                            await downloader.DownloadImage(m.ImagePath, localPath, new CancellationToken());
                        }

                        m.setImagePath(localPath);
                    }
                    else
                    {
                        m.setImagePath("");
                    }
                }

                this.NavigationController.PushViewController(new MovieListController(_movieHelper.MoviesList), true);

                getMoviesButton.Enabled = true;
                movieField.Text         = null;
            };

            this.View.AddSubview(prompt);
            this.View.AddSubview(movieField);
            this.View.AddSubview(getMoviesButton);
        }
Пример #12
0
        /// <summary>
        /// Does an online search of film name entered into the Search Box
        /// Fills the data grid view with all films in Film object format
        /// </summary>
        private async void searchByName()
        {
            var movieAPI   = MovieDbFactory.Create <IApiMovieRequest>().Value;
            int pageNumber = 1;
            int totalPages;
            int numResults = 0;

            ApiSearchResponse <MovieInfo> response = await movieAPI.SearchByTitleAsync(searchBox.Text, pageNumber);

            bs.Clear();

            foreach (MovieInfo info in response.Results)
            {
                Film film = new Film();

                film.Name        = info.Title;
                film.Description = info.Overview;
                film.tmdbID      = info.Id;
                film.tmdbImgUrl  = info.PosterPath;
                film.ReleaseDate = new DateTime(info.ReleaseDate.Year, info.ReleaseDate.Month, info.ReleaseDate.Day);

                bs.Add(film);
                dgvOFilms.DataSource = bs;
                numResults++;
                numResultsLbl.Text = "Page: " + pageNumber.ToString();
            }

            totalPages = response.TotalPages;
            if (numResults == 0)
            {
                MessageBox.Show("No results found");
            }
        }
Пример #13
0
        private UIButton NavigationButton(UITextField nameField, ApiSearchResponse <MovieInfo> response, ImageDownloader downloader, UIActivityIndicatorView activitySpinner)
        {
            var navigateButton = UIButton.FromType(UIButtonType.RoundedRect);

            navigateButton.Frame = new CoreGraphics.CGRect(margin, spaceBetween * 3, this.View.Bounds.Width - (margin * 2), 50);
            navigateButton.SetTitle("See Movie list", UIControlState.Normal);

            navigateButton.TouchUpInside += async(sender, args) =>
            {
                activitySpinner.StartAnimating();
                nameField.ResignFirstResponder();
                response = await _movieApi.SearchByTitleAsync(nameField.Text); //Nær í allar upplýsingar tengdum myndunu

                MovieCredit[] credits = new MovieCredit[response.Results.Count];
                for (int i = 0; i < response.Results.Count; i++)
                {
                    var credit = await _movieApi.GetCreditsAsync(response.Results[i].Id, "en");

                    credits[i] = credit.Item;
                }

                var task = downloader.DownloadImagesFromResponces(response); //Download'ar öllum pósterum

                await task;

                activitySpinner.StopAnimating();
                this.NavigationController.PushViewController(new MovieListController(response, downloader, _movieApi, credits), true);
            };
            return(navigateButton);
        }
Пример #14
0
        private async Task <NeoModels.TVShow> apiSeason(string searchQuery, int season)
        {
            ApiSearchResponse <TVShowInfo> response = await seasonAPI.SearchByNameAsync(searchQuery);

            TVShowInfo info = response.Results[0];
            ApiQueryResponse <DM.MovieApi.MovieDb.TV.TVShow> metadata = await seasonAPI.FindByIdAsync(info.Id);


            NeoModels.TVShow tvshow = new NeoModels.TVShow(metadata.Item, season);

            String        plot       = tvshow.Overview;
            String        poster     = "http://image.tmdb.org/t/p/w342/" + tvshow.Seasons[0].Path;
            string        titleWhole = tvshow.Name + " Season " + season;
            StorageFolder folder     = ApplicationData.Current.LocalFolder;
            string        appPath    = folder.Path;

            appPath += "\\";
            appPath += titleWhole;
            appPath += ".jpg";

            await downloadImage(new Uri(poster), appPath);

            tvshow.Seasons[0].Path = appPath;
            tvshow.PosterPath      = appPath;

            if (seasonList.Instance.existsInList(tvshow))
            {
                already   = true;
                addSeason = tvshow.Seasons[0];
            }

            return(tvshow);
        }
Пример #15
0
        private async Task <NeoModels.Movie> ApiMovieAsync(string searchQuery)
        {
            ApiSearchResponse <MovieInfo> response = await movieAPI.SearchByTitleAsync(searchQuery);

            MovieInfo info = response.Results[0];
            ApiQueryResponse <DM.MovieApi.MovieDb.Movies.Movie> movieinfo = await movieAPI.FindByIdAsync(info.Id);

            ApiQueryResponse <DM.MovieApi.MovieDb.Movies.MovieCredit> credits = await movieAPI.GetCreditsAsync(info.Id);

            NeoModels.Movie movie = new NeoModels.Movie(movieinfo.Item, credits.Item);

            movie.Title = movie.Title.Replace(':', '-');

            String poster = "http://image.tmdb.org/t/p/w342/" + movie.Poster;

            StorageFolder folder  = ApplicationData.Current.LocalFolder;
            string        appPath = folder.Path;

            appPath += "\\";
            appPath += movie.Title;
            appPath += ".jpg";

            await downloadImage(new Uri(poster), appPath);

            movie.Poster = appPath;

            return(movie);
        }
Пример #16
0
        public async Task <List <Movie> > getListOfMoviesMatchingSearch(string nameField)
        {
            List <Movie> responseMovieList = new List <Movie>();

            if (nameField.Length == 0)
            {
                return(responseMovieList);
            }
            else
            {
                ApiSearchResponse <MovieInfo> response = await _movieApi.SearchByTitleAsync(nameField);

                var res = response?.Results;
                if (res != null)
                {
                    foreach (MovieInfo info in response.Results)
                    {
                        responseMovieList.Add(new Movie("")
                        {
                            Id       = info.Id,
                            Title    = $"{info.Title} ({info.ReleaseDate:yyyy})",
                            Actors   = "",
                            ImageUrl = info.PosterPath,
                            Overview = info.Overview
                        });
                    }
                }
            }
            return(responseMovieList);
        }
Пример #17
0
        public async Task GetMostPopularMovies(List <Movie> movieList)
        {
            ApiSearchResponse <MovieInfo> response = await _movieDbApi.GetPopularAsync();

            if (response.Results == null)
            {
                return;
            }

            foreach (MovieInfo movie in response.Results)
            {
                movieList.Add(new Movie
                {
                    Id             = movie.Id,
                    Title          = movie.Title,
                    ReleaseDate    = movie.ReleaseDate,
                    ReleaseYear    = movie.ReleaseDate.Year,
                    RemoteImageUrl = movie.PosterPath,
                    LocalImageUrl  = "",
                    Actors         = new List <String>(),
                    Rating         = movie.VoteAverage
                });
            }
            return;
        }
Пример #18
0
        public async Task <ApiSearchResponse <MovieInfo> > SearchByTitleAsync(string query, int pageNumber = 1, string language = "en")
        {
            var param = new Dictionary <string, string>
            {
                { "query", query },
                { "include_adult", "false" },
                { "language", language },
            };

            const string command = "search/movie";

            ApiSearchResponse <MovieInfo> response = await base.SearchAsync <MovieInfo>(command, pageNumber, param);

            //var config = await GetConfiguration(_settings);
            //var baseImageUrl = string.Format("{0}{1}", config.Images.SecureRootUrl, config.Images.Posters.Last());

            //response.Results.All(movie => { movie.PosterPath = baseImageUrl + movie.PosterPath; return true; });

            if (response.Error != null)
            {
                return(response);
            }

            response.Results.PopulateGenres(_genreApi);

            return(response);
        }
Пример #19
0
        public ArrayList Query(string sQuery)
        {
            // as the factory returns a Lazy<T> instance, simply grab the Value out of the Lazy<T>
            // and assign to a local variable.
            var movieApi = MovieDbFactory.Create <IApiMovieRequest>().Value;

            //ApiSearchResponse<MovieInfo> response = Task.Run(movieApi.SearchByTitleAsync("Star Trek")).result ;
            //apiSearchResponse = movieApi.SearchByTitleAsync(sQuery).Result; //Makes async sync...

            //apiSearchResponse = movieApi.SearchByTitleAsync(sQuery).GetAwaiter().GetResult();

            try
            {
                apiSearchResponse = Task.Run(() =>
                {
                    return(movieApi.SearchByTitleAsync(sQuery));
                }).Result;
            }
            catch
            {
                return(new ArrayList());
            }

            //Console.WriteLine("Movieimage: https://image.tmdb.org/t/p/original/" + apiSearchResponse.Results[0].PosterPath);

            ArrayList pArray = new ArrayList();

            foreach (MovieInfo pMovie in apiSearchResponse.Results)
            {
                DateTime dateTime = pMovie.ReleaseDate;
                pArray.Add(pMovie.OriginalTitle + " (" + dateTime.Year.ToString() + ")");
            }
            return(pArray);
        }
        public async Task SearchByTitleAsync_RunLolaRun_Returns_SingleResult_WithExpectedValues()
        {
            const string runLolaRun = "Run Lola Run";

            ApiSearchResponse <MovieInfo> response = await _api.SearchByTitleAsync(runLolaRun);

            AssertRunLolaRun(response, runLolaRun);
        }
        public async Task GetUpcomingAsync_Returns_ValidResults()
        {
            ApiSearchResponse <Movie> response = await _api.GetUpcomingAsync();

            ApiResponseUtil.AssertErrorIsNull(response);

            ApiResponseUtil.AssertMovieStructure(response.Results);
        }
Пример #22
0
 public MovieListDataSource(ApiSearchResponse <MovieInfo> response, Action <int> onSelectedPerson, ImageDownloader downloader, IApiMovieRequest movieApi, MovieCredit[] credits)
 {
     this._response         = response;
     this._onSelectedPerson = onSelectedPerson;
     this._downloader       = downloader;
     this._movieApi         = movieApi;
     this._credits          = credits;
 }
Пример #23
0
        public async Task SearchByNameAsync_The_Nanny_Returns_ExpectedResults()
        {
            const string theNanny = "The Nanny";

            ApiSearchResponse <TVShowInfo> response = await _api.SearchByNameAsync(theNanny);

            AssertTheNanny(response, theNanny);
        }
Пример #24
0
 protected override void OnAppearing()
 {
     popular = _database.getPopular();
     if (popular != null)
     {
         updateData();
     }
     base.OnAppearing();
 }
        public async Task SearchByTitleAsync_RunLolaRun_Returns_SingleResult_WithExpectedValues_InGerman()
        {
            const string runLolaRun    = "Run Lola Run";
            const string expectedTitle = "Lola rennt";

            ApiSearchResponse <MovieInfo> response = await _api.SearchByTitleAsync(runLolaRun, 1, "de");

            AssertRunLolaRun(response, expectedTitle);
        }
Пример #26
0
        public async Task <List <MovieDetails> > GetTopRatedMovies()
        {
            _movies.Clear();
            ApiSearchResponse <MovieInfo> response = await _movieApi.GetTopRatedAsync();

            _movies = await GetMovies(response.Results);

            return(_movies);
        }
Пример #27
0
 protected override void OnAppearing()
 {
     topRated = _database.getTopRated();
     if (topRated != null)
     {
         updateData();
     }
     base.OnAppearing();
 }
Пример #28
0
        public async Task GetTopRatedAsync_Returns_ValidResult()
        {
            ApiSearchResponse <TVShowInfo> response = await _api.GetTopRatedAsync();

            ApiResponseUtil.AssertErrorIsNull(response);

            IReadOnlyList <TVShowInfo> results = response.Results;

            ApiResponseUtil.AssertTVShowInformationStructure(results);
        }
Пример #29
0
        public async Task SearchByNameAsync_The_Nanny_Returns_ExpectedResults_InGerman()
        {
            const string theNanny = "Die Nanny";

            ApiSearchResponse <TVShowInfo> response = await _api.SearchByNameAsync(theNanny, language : "de");

            ApiResponseUtil.AssertErrorIsNull(response);

            AssertTheNanny(response, theNanny);
        }
        public async Task GetPopularAsync_Returns_ValidResults()
        {
            ApiSearchResponse <MovieInfo> response = await _api.GetPopularAsync();

            ApiResponseUtil.AssertErrorIsNull(response);

            IReadOnlyList <MovieInfo> results = response.Results;

            ApiResponseUtil.AssertMovieInformationStructure(results);
        }
        private void AssertRunLolaRun( ApiSearchResponse<MovieInfo> response, string expectedTitle )
        {
            Assert.AreEqual( 1, response.TotalResults );
            Assert.AreEqual( 1, response.Results.Count );

            MovieInfo movie = response.Results.Single();

            Assert.AreEqual( 104, movie.Id );

            Assert.AreEqual( expectedTitle, movie.Title );

            Assert.AreEqual( new DateTime( 1998, 08, 20 ), movie.ReleaseDate );

            var expectedGenres = new List<Genre>
            {
                GenreFactory.Action(),
                GenreFactory.Drama(),
                GenreFactory.Thriller(),
            };
            CollectionAssert.AreEquivalent( expectedGenres, movie.Genres.ToList() );
        }
        private void AssertTheNanny( ApiSearchResponse<TVShowInfo> response, string theNanny )
        {
            const int theNannyId = 2352;
            const string us = "US";
            const string lang = "en";
            var firstAirDate = new DateTime( 1993, 11, 03 );

            Assert.IsTrue( response.TotalResults > 0 );
            Assert.IsTrue( response.Results.Count > 0 );

            TVShowInfo show = response.Results.Single( x => x.Id == theNannyId );

            Assert.AreEqual( theNanny, show.Name );

            Assert.AreEqual( 1, show.OriginCountry.Count );

            string country = show.OriginCountry.Single();

            Assert.AreEqual( us, country );

            Assert.AreEqual( lang, show.OriginalLanguage );

            Assert.AreEqual( firstAirDate.Date, show.FirstAirDate.Date );
        }