public async Task <ActionResult <MovieDetailsDTO> > Get(int id)
{
var movie = await context.Movies.Where(x => x.Id == id)
.Include(x => x.MovieGenres).ThenInclude(x => x.Genre)
.Include(x => x.MovieActors).ThenInclude(x => x.Person)
.FirstOrDefaultAsync();
if (movie == null)
{
return(NotFound());
}
movie.MovieActors = movie.MovieActors.OrderBy(x => x.Order).ToList();
var model = new MovieDetailsDTO()
{
Movie = movie,
Genres = movie.MovieGenres.Select(x => x.Genre).ToList(),
Actors = movie.MovieActors.Select(x =>
new Person
{
Name = x.Person.Name,
Picture = x.Person.Picture,
Character = x.Character,
Id = x.PersonId
}).ToList()
};
return(model);
}
public async Task <ActionResult> Details(string movieId)
{
MovieDetailsDTO movieDetailsDto = null;
Movie movie = GetMovieFromCache(movieId);
if (!MovieValidator.ValidateMovieId(movieId))
{
return(BadRequest("Please enter a valid movieId"));
}
if (movie == null)
{
var doc = getWebsiteHtmlDocument(movieId);
movieDetailsDto = CreateMovieDetailsDto(movieId, doc);
movie = movieDetailsDto.Adapt <Movie>();
await AddToBothCache(movie);
}
else
{
if (movie.Source == "Database")
{
AddToConcurrentCache(movie);
}
movieDetailsDto = movie.Adapt <MovieDetailsDTO>();
}
return(Ok(movieDetailsDto));
}
//List of all the movies by title
public MovieDetailsDTO GetMovieByTitle(string title)
{
MovieDetailsDTO movieByTitle = (from movie in _DB.Movies
where movie.title == title
select new MovieDetailsDTO()).First();
return(movieByTitle);
}
/*
* Parameter search, true if it's a search, false if it's getting top movies.
* Parameter query, search query if it's a movie search.
*
* This function calls gets the list of movies requested and downloads a poster or them as well.
*
* Returns a list of MoviedDetailsDTO containing all necesary info about movies.
*/
public async Task <List <MovieDetailsDTO> > GetAllMovieInfo(bool search, string query)
{
ApiSearchResponse <MovieInfo> response;
var results = new List <MovieDetailsDTO>();
if (_movieApi == null)
{
return(new List <MovieDetailsDTO>());
}
if (search)
{
response = await _movieApi.SearchByTitleAsync(query);
}
else
{
response = await _movieApi.GetTopRatedAsync();
}
foreach (var res in response.Results)
{
var durationResponse = await _movieApi.FindByIdAsync(res.Id);
var creditResponse = await _movieApi.GetCreditsAsync(res.Id);
string localPath = "";
string casts = "";
var duration = "";
if (_downloader != null)
{
localPath = await _downloader.DownloadImage(res.PosterPath);
}
if (creditResponse.Item != null)
{
for (int i = 0; i < 3; i++)
{
if (creditResponse.Item.CastMembers.Count > i)
{
casts += creditResponse.Item.CastMembers[i].Name + ", ";
}
}
if (casts.Length > 2)
{
casts = casts.Remove(casts.Length - 2);
}
}
if (durationResponse.Item != null)
{
duration = durationResponse.Item.Runtime.ToString();
}
var resp = new MovieDetailsDTO(res, localPath, casts, duration);
results.Add(resp);
}
return(results);
}
private List <ActorDTO> MapMoviesActors(Movie movie, MovieDetailsDTO movieDetails)
{
var result = new List <ActorDTO>();
foreach (var actor in movie.MoviesActors)
{
result.Add(new ActorDTO {
PersonId = actor.PersonId, PersonName = actor.Person.Name, Character = actor.CharacterName
});
}
return(result);
}
private List <CasterDTO> MapMovieCasters(Movie movie, MovieDetailsDTO movieDetailsDTO)
{
var result = new List <CasterDTO>();
foreach (var caster in movie.Casters)
{
result.Add(new CasterDTO()
{
PersonId = caster.PersonId, Character = caster.Character, PersonName = caster.Person.Name
});
}
return(result);
}
private List <GenreDTO> MapMoviesGenres(Movie movie, MovieDetailsDTO movieDetailsDTO)
{
var result = new List <GenreDTO>();
foreach (var moviegenre in movie.MoviesGenres)
{
result.Add(new GenreDTO()
{
Id = moviegenre.GenreId, Name = moviegenre.Genre.Name
});
}
return(result);
}
//parameters receiving Movie movie, MovieDetailsDTO movieDetailsDTO
private List <ActorDTO> MapMoviesActors(Movie movie, MovieDetailsDTO movieDetailsDTO)
{
//we created ActorDTO as we want to send MovieDetailsDTO and not Movie object as whole,
//as Movie object has lot of info that we don't wanna share.
var result = new List <ActorDTO>();
foreach (var actor in movie.MoviesActors)
{
result.Add(new ActorDTO()
{
PersonId = actor.PersonId, Character = actor.Character, PersonName = actor.Person.Name
});
}
return(result);
}
//parameters receiving Movie movie, MovieDetailsDTO movieDetailsDTO
private List <GenreDTO> MapMoviesGenres(Movie movie, MovieDetailsDTO movieDetailsDTO)
{
//we created GenreDTO as we want to send MovieDetailsDTO and not Movie object as whole,
//as Movie object has lot of info that we don't wanna share.
var result = new List <GenreDTO>();
foreach (var moviegenre in movie.MoviesGenres)
{
result.Add(new GenreDTO()
{
Id = moviegenre.GenreId, Name = moviegenre.Genre.Name
});
}
return(result);
}
public async Task <MovieDetailsDTO> GetMovieDetails(string movieId)
{
_uri = $"movie/{movieId}?api_key={_key}&language=en-US";
var movieDetailsForId = new MovieDetailsDTO();
try
{
movieDetailsForId = await _movieDbApiCall.CallMovieDBApi(_uri);
}
catch
{
Console.WriteLine("Exception trying to retrieve data");
}
return(movieDetailsForId);
}
public async Task <MovieDetailsDTO> GetLatestMovies()
{
_uri = $"movie/latest?api_key={_key}&language=en-US";
var detailLatest = new MovieDetailsDTO();
try
{
detailLatest = await _movieDbApiCall.CallMovieDBApi(_uri);
}
catch
{
Console.WriteLine("Exception trying to retrieve data");
}
return(detailLatest);
}
public MovieDetailsDTO Get(int id)
{
Movie Movie = IMovieRepository.Get(id);
MovieDetailsDTO MyMovie = new MovieDetailsDTO()
{
Title = Movie.Title,
ReleaseDate = Movie.ReleaseDate,
RunTime = Movie.RunTime,
Vote = Movie.Vote
};
IEnumerable <MovieActor> MyMovieActors = IMovieActorRepository.GetAll().Where(x => x.MovieId == Movie.Id);
if (MyMovieActors != null)
{
List <string> MovieActorList = new List <string>();
foreach (MovieActor MyMovieActor in MyMovieActors)
{
Actor MyActor = IActorRepository.GetAll().SingleOrDefault(x => x.Id == MyMovieActor.ActorId);
MovieActorList.Add(MyActor.Name);
}
MyMovie.ActorName = MovieActorList;
}
IEnumerable <MovieCompany> MyMovieCompanies = IMovieCompanyRepository.GetAll().Where(x => x.MovieId == Movie.Id);
if (MyMovieCompanies != null)
{
List <string> MovieCompanyList = new List <string>();
foreach (MovieCompany MyMovieCompany in MyMovieCompanies)
{
Company MyCompany = ICompanyRepository.GetAll().SingleOrDefault(x => x.Id == MyMovieCompany.CompanyId);
MovieCompanyList.Add(MyCompany.Name);
}
MyMovie.CompanyName = MovieCompanyList;
}
IEnumerable <MovieGenre> MyMovieGenres = IMovieGenreRepository.GetAll().Where(x => x.MovieId == Movie.Id);
if (MyMovieGenres != null)
{
List <string> MovieGenreList = new List <string>();
foreach (MovieGenre MyMovieGenre in MyMovieGenres)
{
Genre MyGenre = IGenreRepository.GetAll().SingleOrDefault(x => x.Id == MyMovieGenre.GenreId);
MovieGenreList.Add(MyGenre.Name);
}
MyMovie.GenreName = MovieGenreList;
}
return(MyMovie);
}
public async Task <MovieDetailsDTO> GetNowPlaying()
{
_uri = $"movie/now_playing?api_key={_key}&language=en-US&page=1";
var movieDetailsNowPlaying = new MovieDetailsDTO();
try
{
movieDetailsNowPlaying = await _movieDbApiCall.CallMovieDBApi(_uri);
}
catch
{
Console.WriteLine("Exception Trying to get data");
}
return(movieDetailsNowPlaying);
}
private List <ActorMovieDetailDTO> MapMovieActors(Movie movie, MovieDetailsDTO movieDetailsDTO)
{
var results = new List <ActorMovieDetailDTO>();
if (movie.MoviesGenders == null)
{
return(results);
}
foreach (var item in movie.MoviesActors)
{
results.Add(new ActorMovieDetailDTO {
ActorId = item.ActorId, Name = item.Actor.Name, Character = item.Character
});
}
return(results);
}
private List <ActorMovieDetailDTO> MapMoviesActors(Movie movie, MovieDetailsDTO movieDetailsDTO)
{
var result = new List <ActorMovieDetailDTO>();
if (movie.MoviesActors == null)
{
return(result);
}
foreach (var actorMovie in movie.MoviesActors)
{
result.Add(new ActorMovieDetailDTO {
ActorId = actorMovie.ActorId, Character = actorMovie.Character, NamePerson = actorMovie.Actor.Name
});
}
return(result);
}
public async Task <MovieDetailsDTO> GetUpcomingMovieDetail()
{
_uri = "upcoming?api_key={_key}&language=en-US&page=1";
var movieDetailsUpcomingTitles = new MovieDetailsDTO();
try
{
movieDetailsUpcomingTitles = await _movieDbApiCall.CallMovieDBApi(_uri);
}
catch
{
Console.WriteLine("Exception trying to get data");
}
return(movieDetailsUpcomingTitles);
}
private List <GenderDTO> MapMovieGenders(Movie movie, MovieDetailsDTO movieDetailsDTO)
{
var results = new List <GenderDTO>();
if (movie.MoviesGenders == null)
{
return(results);
}
foreach (var item in movie.MoviesGenders)
{
results.Add(new GenderDTO {
Id = item.GenderId, Name = item.Gender.Name
});
}
return(results);
}
private List <GenderDTO> MapMoviesGenders(Movie movie, MovieDetailsDTO movieDetailsDTO)
{
var result = new List <GenderDTO>();
if (movie.MoviesGenders == null)
{
return(result);
}
foreach (var genderMovie in movie.MoviesGenders)
{
result.Add(new GenderDTO()
{
Id = genderMovie.GenderId, Name = genderMovie.Gender.Name
});
}
return(result);
}
//List of all the movies by title
public MovieDetailsDTO GetMovieByTitle(string title)
{
MovieDetailsDTO movieByTitle = (from movie in _DB.Movies
where movie.title == title
select new MovieDetailsDTO()
{
Id = movie.id,
Title = movie.title,
OriginalTitle = movie.original_title,
Runtime = (int)movie.runtime,
Posterpath = movie.posterpath,
GenreList = GetGenresByMovieId(movie.id),
DirectorList = GetDirByMovieId(movie.id),
ActorList = GetActorsByMovieId(movie.id)
}).First();
return(movieByTitle);
}
private List <MoviesDetailActorsDTO> MapActorDetails(Movie movie, MovieDetailsDTO movieDetailDTO)
{
var result = new List <MoviesDetailActorsDTO>();
if (movie.MoviesActors == null)
{
return(result);
}
foreach (var actor in movie.MoviesActors)
{
result.Add(new MoviesDetailActorsDTO()
{
ActorId = actor.ActorId, ActorName = actor.Actor.Name, Character = actor.Character
});
}
return(result);
}
public async Task <MovieDetailsDTO> getMovieDetails(string movieId)
{
using (HttpClient httpClient = new HttpClient())
{
try
{
HttpResponseMessage response = await httpClient.GetAsync($"http://localhost:50276/api/Movies/Details/{movieId}");
response.EnsureSuccessStatusCode();
string responseContent = await response.Content.ReadAsStringAsync();
MovieDetailsDTO movieDetails = JsonConvert.DeserializeObject <MovieDetailsDTO>(responseContent);
return(movieDetails);
}
catch (HttpRequestException e)
{
Console.WriteLine(e.Message);
throw e;
}
}
}
public MovieInfoController(MovieDetailsDTO dto)
{
this._movie = dto;
}
public async Task <ActionResult <MovieDetailsDTO> > Get(int id)
{
var movie = await _dbContext.Movies.Where(x => x.Id == id)
.Include(x => x.MoviesGenres).ThenInclude(x => x.Genre)
.Include(x => x.MoviesActors).ThenInclude(x => x.Person)
.Include(x => x.MoviesTheaters).ThenInclude(x => x.Theater)
.FirstOrDefaultAsync();
if (movie == null)
{
return(NotFound());
}
var averageVote = 0.0;
var userVote = 0;
if (await _dbContext.MovieRatings.AnyAsync(x => x.MovieId == id))
{
averageVote = await _dbContext.MovieRatings.Where(x => x.MovieId == id)
.AverageAsync(x => x.Rate);
if (User.Identity.IsAuthenticated)
{
var user = await _userManager.FindByEmailAsync(User.Identity.Name);
var userId = user.Id;
var userVoteInDb = await _dbContext.MovieRatings
.FirstOrDefaultAsync(x => x.MovieId == id && x.UserId == userId);
if (userVoteInDb != null)
{
userVote = userVoteInDb.Rate;
}
}
}
movie.MoviesActors = movie.MoviesActors.OrderBy(x => x.Order).ToList();
var model = new MovieDetailsDTO
{
Movie = movie,
UserVote = userVote,
AverageVote = averageVote,
Genres = movie.MoviesGenres.Select(x => x.Genre).ToList()
};
model.Actors = movie.MoviesActors.Select(x =>
new Person
{
Name = x.Person.Name,
Picture = x.Person.Picture,
Character = x.Character,
Id = x.PersonId
}).ToList();
model.Theaters = movie.MoviesTheaters.Select(x =>
new Theater
{
Name = x.Theater.Name,
Address = x.Theater.Address,
Id = x.TheaterId
}).ToList();
return(model);
}
