public async Task <BrowseItem> BrowseTV(FirebaseItem item)
{
HttpResponseMessage response = await client.GetAsync($"tv/{item.ID}?api_key={api}");
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
MovieDetail movieResponse = JsonConvert.DeserializeObject <MovieDetail>(content);
if (movieResponse != null)
{
return(new BrowseItem
{
ID = item.ID,
Image = imageSource + movieResponse.backdrop_path,
Title = movieResponse.original_title ?? movieResponse.name,
Type = "tv series",
Realised = item.Realised,
ToRealise = item.ToRealise
});
}
}
return(new BrowseItem());
}
private static double GetAvgRatingOfMovie(MovieDetail movieDetail)
{
double avgRating = 0;
foreach (var item in movieDetail.OMDbMovieDetail.Ratings)
{
Double doubleRating = 0;
if (item.Source.Equals("Rotten Tomatoes"))
{
doubleRating = Convert.ToDouble(item.Value.Replace("%", "")) * 0.1;
}
else
{
doubleRating = Convert.ToDouble(item.Value.Split("/")[0]);
}
avgRating += doubleRating;
}
if (movieDetail.OMDbMovieDetail.Ratings.Count > 0)
{
avgRating = avgRating / movieDetail.OMDbMovieDetail.Ratings.Count;
}
return(avgRating);
}
public IActionResult GetMovieDetail(string imdbID)
{
try
{
MovieDetailViewModel movieDetailViewModel = new MovieDetailViewModel();
if (string.IsNullOrEmpty(imdbID))
{
MovieViewModel movieViewModel = new MovieViewModel();
movieViewModel.Message = "Please try clicking the link again";// could be user remove the imdID from url
return(View("~/Views/Movie/Search.cshtml", movieViewModel));
}
imdbID = imdbID.Trim();
MovieDetail movieDetail = _movieService.GetMovieDetail(imdbID);
if (movieDetail != null)
{
string jsonLD = _jsonLDService.CreateJsonLDMovie(movieDetail);
movieDetailViewModel.JsonLDMovie = jsonLD;
movieDetailViewModel.MovieDetail = movieDetail;
}
else
{
movieDetailViewModel.Message = "There is some error. Please try again later";
}
return(View("~/Views/Movie/Detail.cshtml", movieDetailViewModel));
}
catch (Exception ex)
{
}
return(View("~/Views/Movie/Detail.cshtml", null));
}
private async void GetData(int iMovie)
{
MovieDetail oMovieDetail = new MovieDetail();
oMovieDetail = await cpFeeds.GetMoviesDetail(iMovie);
Date = oMovieDetail.release_date;
string St = "";
for (int r = 0; r < oMovieDetail.production_companies.Length; r++)
{
St += oMovieDetail.production_companies[r].name;
if (r < 3)
{
St += ",";
}
}
Studio = St;
string Gn = "";
for (int rr = 0; rr < oMovieDetail.genres.Length; rr++)
{
Gn += oMovieDetail.genres[rr].name;
if (rr < 3)
{
Gn += ",";
}
}
Genero = Gn;
}
private async void GetMovieDetail()
{
if (string.IsNullOrEmpty(_movieId))
{
return;
}
using (HttpClient client = new HttpClient())
{
string url = $"http://www.omdbapi.com/?i={_movieId}&apikey=32941a88";
string result = await client.GetStringAsync(url);
if (string.IsNullOrEmpty(result))
{
return;
}
MovieDetail movieDetail = await Json.ToObjectAsync <MovieDetail>(result);
if (movieDetail == null)
{
return;
}
CurrentMovieDetail = movieDetail;
}
}
public async Task <MovieDetail> Get(int id)
{
MovieDetail movieDetail = new MovieDetail();
var request = new HttpRequestMessage(HttpMethod.Get,
"https://www.rottentomatoes.com/api/private/v1.0/movies/" + id);
request.Headers.Add("Accept", "application/json");
//request.Headers.Add("User-Agent", "HttpClientFactory-Sample");
var client = clientFactory.CreateClient();
var response = await client.SendAsync(request);
if (response.IsSuccessStatusCode)
{
using var responseStream = await response.Content.ReadAsStreamAsync();
movieDetail = await JsonSerializer.DeserializeAsync <MovieDetail>(responseStream);
}
else
{
//GetBranchesError = true;
//movieDetail = Array.Empty<MovieDetail>();
}
return(movieDetail);
}
public override List <MovieDetail> ParseMovies(string html)
{
var dom = htmlParser.Parse(html);
var movies = new List <MovieDetail>();
var lis = dom.QuerySelectorAll("div.xing_vb")?.SelectMany(div => div.QuerySelectorAll("li"));
foreach (var li in lis)
{
if (li.QuerySelector("a") == null || string.IsNullOrEmpty(li.QuerySelector(".xing_vb5")?.TextContent))
{
continue;
}
var onlineURL = "http://www.btrenren.com" + li.QuerySelector("a").GetAttribute("href");
DateTime.TryParse(li.QuerySelector(".xing_vb6")?.TextContent, out var publishTime);
var movie = new MovieDetail()
{
Name = li.QuerySelector("a").TextContent,
Link = onlineURL,
Type = li.QuerySelector(".xing_vb5")?.TextContent,
PublishTime = publishTime,
UpdateTime = DateTime.Now
};
FillMovieDetail(onlineURL, movie);
movies.Add(movie);
}
return(movies);
}
protected void FillMovieDetail(string onlineURL, MovieDetail movie)
{
var movieHTML = LoadHTML(onlineURL);
if (!string.IsNullOrEmpty(movieHTML))
{
var htmlDoc = htmlParser.Parse(movieHTML);
movie.Cover = htmlDoc?.QuerySelector("div.vodImg")?.QuerySelector("img")?.GetAttribute("src");
var vodplayinfos = htmlDoc?.QuerySelectorAll("div.vodplayinfo");
if (vodplayinfos.Count() > 2)
{
movie.Intro = vodplayinfos[1]?.TextContent;
movie.DownResources = new List <Resource>();
if (vodplayinfos[2].QuerySelectorAll("li").Any())
{
movie.DownResources.AddRange(GetResources(vodplayinfos[2]));
}
if (vodplayinfos[3].QuerySelectorAll("li").Any())
{
movie.DownResources.AddRange(GetResources(vodplayinfos[3]));
}
}
}
}
private static double GetActorAvgGross(MovieDetail targetMovie)
{
Dictionary <String, Double> movieDetailDict = new Dictionary <string, Double>();
foreach (var cast in targetMovie.MovieCredit.Casts)
{
foreach (var movie in movieDetails)
{
if (movie.MovieCredit.Casts.Exists(x => x.Name == cast.Name))
{
if (movieDetailDict.ContainsKey(movie.ImdbId) == false)
{
if (movie.Revenue > 0)
{
movieDetailDict.Add(movie.ImdbId, movie.Revenue);
}
}
}
}
}
if (movieDetailDict.Count == 0)
{
return(0);
}
return(movieDetailDict.Sum(x => x.Value) / movieDetailDict.Count);
}
public async Task <ActionResult <MovieDetail> > PostMovieDetail(MovieDetail movieDetail)
{
_context.MovieDetail.Add(movieDetail);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMovieDetail", new { id = movieDetail.MovieDetailId }, movieDetail));
}
public async Task <DetailItem> TvDetail(string ID)
{
HttpResponseMessage response = await client.GetAsync($"tv/{ID}?api_key={api}");
if (response.IsSuccessStatusCode)
{
string content = await response.Content.ReadAsStringAsync();
MovieDetail movieResponse = JsonConvert.DeserializeObject <MovieDetail>(content);
if (movieResponse != null)
{
string genres = String.Join(", ", movieResponse.genres.Select(x => x.name));
return(new DetailItem()
{
Title = movieResponse.original_title ?? movieResponse.name,
VoteAverage = movieResponse.vote_average,
Runtime = TimeConverter(movieResponse.episode_run_time[0]),
Release = movieResponse.first_air_date != null?Convert.ToDateTime(movieResponse.first_air_date).ToShortDateString() : "",
Poster = imageSource + movieResponse.poster_path,
Background = imageSource + movieResponse.backdrop_path,
Genres = genres,
Overview = movieResponse.overview,
Cast = await TvCast(ID)
});
}
}
return(null);
}
/**
* Constructor
* */
public VM_MovieRootFrame() : base()
{
List = new DisplayMovies();
Detail = new MovieDetail();
MessengerInstance.Register <STATE>(this, "state_changed", StateChangedAck);
OpenCreateMovie = new RelayCommand(() => GoToAddMovie());
}
/// <summary>
/// GetMovieByIdAndProvider
/// </summary>
/// <param name="id"></param>
/// <param name="provider"></param>
/// <returns></returns>
public async Task <MovieDetail> GetMovieByIdAndProvider(string id, string provider)
{
MovieDetail movieDetail = null;
try
{
logger.Info("Request Movie by ID {0} Provider: {1}", provider, id);
HttpResponseMessage response = await _baseService.GetDataFromExternalAPI(provider + "/movie/" + id);
if (response != null && response.IsSuccessStatusCode)
{
var obj = response.Content.ReadAsStringAsync().Result;
if (obj != null)
{
string jsonstring = JsonConvert.SerializeObject(obj);
var deserializedString = JsonConvert.DeserializeObject <string>(jsonstring);
movieDetail = JsonConvert.DeserializeObject <MovieDetail>(deserializedString);
}
}
}
catch (Exception ex)
{
logger.Error(ex, "Unable to Fetch Movie with Id: {0} and Provider: {1}", id, provider);
}
return(movieDetail);
}
// <summary>
// Get FullMovie Details
// </summary>
// <returns></returns>
public async Task <List <MovieDetail> > GetFullMovieDetails()
{
List <MovieDetail> movieDetails = new List <MovieDetail>();
try
{
if (_cache.TryGetValue(Constants.MovieDetails, out IEnumerable <MovieDetail> moviesDetailsCache))
{
return(moviesDetailsCache.ToList());
}
List <Movie> movies = await GetMovies();
logger.Info("Count of movies to Fetch movie details by provider and Id : {0}", movies.Count);
foreach (Movie movie in movies)
{
MovieDetail movieDetail = await GetMovieByIdAndProvider(movie.Id, movie.Provider);
if (movieDetail != null)
{
movieDetail.Provider = movie.Provider;
movieDetails.Add(movieDetail);
}
}
if (movieDetails != null && movieDetails.Count != 0)
{
_cache.Set(Constants.MovieDetails, movieDetails);
}
}
catch (Exception ex)
{
logger.Error(ex, "Unable to Fetch Movie Details");
}
return(movieDetails);
}
public async Task <IMovieDetail> GetMovieDetailAsync(int movieID)
{
var movieDetail = await ApiHandler.GetApi <MovieDetailsRootDTO>($"/movie/{movieID}?language=en-US&");
var result = new MovieDetail()
{
Adult = movieDetail.adult,
Budget = movieDetail.budget,
Genres = movieDetail.genres,
Id = movieDetail.id,
Original_language = movieDetail.original_language,
Original_title = movieDetail.original_title,
Overview = movieDetail.overview,
Popularity = movieDetail.popularity,
Poster_path = "https://image.tmdb.org/t/p/w500" + movieDetail.poster_path,
Release_date = movieDetail.release_date,
Revenue = movieDetail.revenue,
Runtime = movieDetail.runtime,
Spoken_languages = movieDetail.spoken_languages,
Status = movieDetail.status,
Tagline = movieDetail.tagline,
Title = movieDetail.title,
Vote_average = movieDetail.vote_average * 10,
movieTrailerURL = await GetMovieTrailerURLByID(movieDetail.id),
videoUrls = await GetMovieVideosURLByID(movieDetail.id),
RecommendedMovies = await GetMovieRecommendations(movieDetail.id),
movieReviews = (await GetMovieReviews(movieDetail.id))?.ToList(),
movieImages = (MovieImages) await GetMovieImagesAsync(movieDetail.id),
backDropPath = "https://image.tmdb.org/t/p/w500" + movieDetail.backdrop_path
};
return(result);
}
// GET: Movie/Edit/5
public ActionResult Edit(int id)
{
MovieDetail model = userUC.DisplayMovieDetail(id);
//TODO EF to Common.MTO.MovieDetail
return(View(model));
}
public async Task <MovieDetail> GetMovieDetail(int id)
{
ApiQueryResponse <Movie> movieInfo = await _api.FindByIdAsync(id);
MovieDetail movie = new MovieDetail();
if (movieInfo.Item != null)
{
movie = new MovieDetail()
{
title = movieInfo.Item.Title,
runtime = movieInfo.Item.Runtime.ToString(),
description = movieInfo.Item.Overview,
tagLine = movieInfo.Item.Tagline,
budget = movieInfo.Item.Budget.ToString(),
};
var movieGenre = "";
for (int i = 0; i < movieInfo.Item.Genres.Count; i++)
{
if (i + 1 == movieInfo.Item.Genres.Count)
{
movieGenre += movieInfo.Item.Genres[i];
}
else
{
movieGenre += movieInfo.Item.Genres[i] + ", ";
}
}
movie.genres = movieGenre;
}
return(movie);
}
public Detail(MovieDetail movie, MovieService api)
{
this._movie = movie;
_detailViewModel = new DetailViewModel(movie, api);
this.BindingContext = this._detailViewModel;
InitializeComponent();
}
public async Task <IActionResult> PutMovieDetail(long id, MovieDetail movieDetail)
{
if (id != movieDetail.MovieDetailId)
{
return(BadRequest());
}
_context.Entry(movieDetail).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieDetailExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
// GET api/<controller>/xyz
public async Task <HttpResponseMessage> Get(string movieId)
{
MovieDetail movie = new MovieDetail();
movie = GlobalCachingProvider.Instance.GetItem(movieId, remove: false) as MovieDetail;
if (movie != null)
{
return(Request.CreateResponse(System.Net.HttpStatusCode.OK, movie));
}
else
{
try
{
using (HttpClient httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Add(Constants.WebjetTokenName, Constants.WebjetTokenValue);
HttpResponseMessage response = await httpClient.GetAsync(string.Format(Constants.WebjetMovieURL, movieId));
response.EnsureSuccessStatusCode();
var result = await response.Content.ReadAsStringAsync();
Logger.Write(LogLevel.INFO, string.Format("Movie data retrieved for ID: {0}", movieId));
movie = JsonConvert.DeserializeObject <MovieDetail>(result);
GlobalCachingProvider.Instance.AddItem(movieId, movie);
return(Request.CreateResponse(System.Net.HttpStatusCode.OK, movie));
}
}
catch (Exception ex)
{
Logger.Write(LogLevel.ERROR, ex.Message);
return(Request.CreateResponse(System.Net.HttpStatusCode.InternalServerError, string.Format("Could not get movie for ID: {0}", movieId)));
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Description,BoxOffice,MovieId")] MovieDetail movieDetail)
{
if (id != movieDetail.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movieDetail);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieDetailExists(movieDetail.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["MovieId"] = new SelectList(_context.Set <Movie>(), "Id", "Id", movieDetail.MovieId);
return(View(movieDetail));
}
public void AddToUserCollection(MovieDetail imdbmovie)
{
try
{
var movie = new MovieDetail
{
Director = imdbmovie.Director,
Genre = imdbmovie.Genre,
imdbID = imdbmovie.imdbID,
Poster = imdbmovie.Poster,
Title = imdbmovie.Title,
Year = imdbmovie.Year,
UserID = userId,
Actors = imdbmovie.Actors,
Country = imdbmovie.Country
};
// TODO: Add insert logic here
unitOfWork.MovieDetailRepository.Create(movie);
unitOfWork.SaveChanges();
}
catch (Exception)
{
throw new Exception("Movie not added to list");
}
}
/// <summary>
/// Search Movies by ID and Returns movie object ignoring any errors
/// </summary>
/// <param name="ID"></param>
/// <returns></returns>
private async Task <MovieDetail> GetMovieDetails(string ID)
{
MovieDetail movieDetail = null;
if (ID.StartsWith("cw", StringComparison.OrdinalIgnoreCase))
{
try
{
movieDetail = await cinemaWorldClient.GetMovieDetails(cancellationTokenSource.Token, ID);
return(movieDetail);
}
catch (Exception e)
{
logger.LogError("CinemaWorldClient.GetMovieDetails()- Exception occured", e);
}
}
else
{
try
{
movieDetail = await filmWorldClient.GetMovieDetails(cancellationTokenSource.Token, ID);
return(movieDetail);
}
catch (Exception e)
{
logger.LogError("FilmWorldClient.GetMovieDetails()- Exception occured", e);
}
}
return(movieDetail);
}
private decimal CalculateCheapPrice(MovieDetail cinemaWorldMovie, MovieDetail filmWoldMovie)
{
var cinemaPrice = decimal.Parse(cinemaWorldMovie.Price);
var filmWorldPrice = decimal.Parse(filmWoldMovie.Price);
return(cinemaPrice > filmWorldPrice ? filmWorldPrice : cinemaPrice);
}
private MovieDetail BuildMovieDetailModel(MovieDetail cinemaWorldMovie, MovieDetail filmWorldMovie)
{
MovieDetail moveDetail = null;
if (cinemaWorldMovie != null)
{
moveDetail = cinemaWorldMovie;
}
else if (filmWorldMovie != null)
{
moveDetail = filmWorldMovie;
}
if (moveDetail != null && cinemaWorldMovie != null && filmWorldMovie != null)
{
moveDetail.Price = CalculateCheapPrice(cinemaWorldMovie, filmWorldMovie).ToString();
}
if (moveDetail != null)
{
moveDetail.ID = GetMovieDigitId(moveDetail.ID);
}
return(moveDetail);
}
public ActionResult Delete(int?id)
{
MovieService service = new MovieService();
MovieDetail movie = service.GetMovieById(id);
return(View(movie));
}
public async Task GetDetailMovie(string MovieId)
{
getDetailMovieQuery = $"{URL_BASE_APIREST}/{MovieId}?api_key={Environment.THEMOVIEDB_API_KEY}&language=en-US";
var movieDetail = new MovieDetail();
var client = new HttpClient();
var response = await client.GetAsync(getDetailMovieQuery);
if (response.IsSuccessStatusCode)
{
var ContentString = await response.Content.ReadAsStringAsync();
movieDetail = JsonConvert.DeserializeObject <MovieDetail>(ContentString);
if (movieDetail != null)
{
movieDetail.PosterImage = URL_BASE_IMAGE + movieDetail.PosterImage;
var splitData = movieDetail.Release.Split('-');
if (splitData.Any())
{
movieDetail.Release = splitData[0];
}
}
movieDetail.Casts = await GetCastsMovie(MovieId);
}
GetDetailMovie_Completed?.Invoke(this, new GenericEventArg <MovieDetail>(movieDetail));
}
public IActionResult Delete(int id, MovieDetail m1)
{
var moviedetails = context.MovieDetails.Where(x => x.MovieDetailId == id).SingleOrDefault();
context.MovieDetails.Remove(moviedetails);
context.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <MovieDetail> Get(int id)
{
MovieDetail movieDetail = new MovieDetail();
movieDetail = await projectAAL.Get(id);
return(movieDetail);
}
public async Task <IActionResult> Detail(int id)
{
MovieDetail list = new MovieDetail();
list = await project.Get(id);
return(View(list));
}
