Example #1
0
        public void ShouldReturnMovies()
        {
            var movieId = 11;
            var movieDb = new MovieDB {
                Title = "Title"
            };
            var movieDbs = new List <MovieDB> {
                movieDb
            };
            var movieDbResponse = new MovieDBResponse {
                Movies = movieDbs, Count = 1
            };
            var movie = new Movie {
                Title = "Title"
            };
            var movies = new List <Movie> {
                movie
            };

            _mockMovieRepository.Setup(r => r.GetAll()).Returns(movieDbResponse);
            _mockMovieConverter.Setup(c => c.ConvertToMovie(It.IsAny <MovieDB>())).Returns(movie);
            var movieService = new MovieService(_mockMovieRepository.Object, _mockMovieConverter.Object);

            var result = movieService.All();

            Assert.Equal(1, result.Count);
            Assert.Equal(movie, result.Movies.First());
        }
Example #2
0
        public void ShouldConvertMovies()
        {
            var movieId = 11;
            var movieDb = new MovieDB {
                Title = "Title"
            };
            var movieDbs = new List <MovieDB> {
                movieDb
            };
            var movieDbResponse = new MovieDBResponse {
                Movies = movieDbs, Count = 1
            };
            var movie = new Movie {
                Title = "Title"
            };
            var movies = new List <Movie> {
                movie
            };

            _mockMovieRepository.Setup(r => r.GetAll()).Returns(movieDbResponse);
            _mockMovieConverter.Setup(c => c.ConvertToMovie(It.IsAny <MovieDB>())).Returns(movie);
            var movieService = new MovieService(_mockMovieRepository.Object, _mockMovieConverter.Object);

            movieService.All();

            _mockMovieConverter.Verify(c => c.ConvertToMovie(It.IsAny <MovieDB>()), Times.Once);
        }
        public StringContent FetchMovieListAsync(string query)
        {
            SearchContainer <SearchMovie> results = _client.SearchMovieAsync(query).Result;

            StringBuilder          str   = new StringBuilder();
            List <MovieDBResponse> items = new List <MovieDBResponse>();

            foreach (SearchMovie searchMovie in results.Results)
            {
                MovieDBResponse movieDBResponse = new MovieDBResponse();
                movieDBResponse.BackdropPath  = searchMovie.BackdropPath;
                movieDBResponse.Id            = searchMovie.Id;
                movieDBResponse.OriginalTitle = searchMovie.OriginalTitle;
                movieDBResponse.OverView      = searchMovie.Overview;
                movieDBResponse.PosterPath    = searchMovie.PosterPath;
                movieDBResponse.ReleaseDate   = searchMovie.ReleaseDate;
                movieDBResponse.VoteAverage   = searchMovie.VoteAverage;
                movieDBResponse.Votecount     = searchMovie.VoteCount;
                movieDBResponse.Popularity    = searchMovie.Popularity;
                //str.Append(JsonConvert.SerializeObject(movieDBResponse));
                items.Add(movieDBResponse);
            }

            return(GetStaticcontent(JsonConvert.SerializeObject(items)));
        }
 private static void GetMoveInfo(MovieReviewResponse movieReviewResponse, MovieDBResponse moveinfo)
 {
     movieReviewResponse.BackdropPath  = moveinfo.BackdropPath;
     movieReviewResponse.OriginalTitle = moveinfo.OriginalTitle;
     movieReviewResponse.OverView      = moveinfo.OverView;
     movieReviewResponse.PosterPath    = moveinfo.PosterPath;
     movieReviewResponse.ReleaseDate   = moveinfo.ReleaseDate;
     movieReviewResponse.Popularity    = moveinfo.Popularity;
     movieReviewResponse.Id            = moveinfo.Id;
 }
        public StringContent GetBlockChain(string query)
        {
            String    blockChain     = string.Empty;
            WebClient web            = new WebClient();
            string    blockChainPath = ConfigurationManager.AppSettings["BlockChainURL"].ToString();

            System.IO.Stream stream = web.OpenRead(blockChainPath);
            List <MovieBlockChainResponse> items = new List <MovieBlockChainResponse>();

            using (System.IO.StreamReader reader = new System.IO.StreamReader(stream))
            {
                blockChain = reader.ReadToEnd();
                IList <JToken> results = JObject.Parse(blockChain)["blockchain"].Values("data").ToList();

                int index = 0;
                MovieReviewResponse movieReviewResponse = new MovieReviewResponse();
                foreach (JToken result in results)
                {
                    if (index == 0)
                    {
                        index++;
                        continue;
                    }
                    dynamic userinfo = JsonConvert.DeserializeObject <object>(result.ToString());

                    if (userinfo.userName.Value.ToString() == query)
                    {
                        int currentmovieid = 0;
                        int.TryParse(userinfo.movieId.Value.ToString(), out currentmovieid);
                        MovieDBResponse moveinfo = GetMovieInfo(currentmovieid);

                        if (moveinfo != null && movieReviewResponse.OverView == null)
                        {
                            GetMoveInfo(movieReviewResponse, moveinfo);
                        }
                        MovieBlockChainResponse movieBlockChainResponse = new MovieBlockChainResponse();
                        {
                            GetUserInformation(blockChain, index, userinfo, movieBlockChainResponse);
                        };

                        items.Add(movieBlockChainResponse);
                    }
                    index++;
                }
                movieReviewResponse.Votecount   = items.Count;
                movieReviewResponse.VoteAverage = Math.Round((double)items.Count / 5);
                movieReviewResponse.Reviews     = items;
                return(GetStaticcontent(JsonConvert.SerializeObject(movieReviewResponse).ToString()));
            }
        }
        private MovieDBResponse GetMovieInfo(int movieID)
        {
            Task <Movie> results = _client.GetMovieAsync(movieID);

            MovieDBResponse movieDBResponse = new MovieDBResponse();

            movieDBResponse.BackdropPath  = results.Result.BackdropPath;
            movieDBResponse.Id            = results.Result.Id;
            movieDBResponse.OriginalTitle = results.Result.OriginalTitle;
            movieDBResponse.OverView      = results.Result.Overview;
            movieDBResponse.PosterPath    = results.Result.PosterPath;
            movieDBResponse.ReleaseDate   = results.Result.ReleaseDate;
            movieDBResponse.VoteAverage   = results.Result.VoteAverage;
            movieDBResponse.Votecount     = results.Result.VoteCount;
            movieDBResponse.Popularity    = results.Result.Popularity;
            return(movieDBResponse);
        }
        public StringContent FetchMovieInfo(int movieID)
        {
            MovieDBResponse movieDBResponse = GetMovieInfo(movieID);

            return(GetStaticcontent(JsonConvert.SerializeObject(movieDBResponse).ToString()));
        }