public async Task <IActionResult> Create(MovieImage movieImage, IFormFile fileContents)
{
// set FileContents
using var ms = new MemoryStream();
fileContents.CopyTo(ms);
byte[] fileBytes = ms.ToArray();
movieImage.FileContents = fileBytes;
// set file extension
string fileExtension = new FileInfo(fileContents.FileName).Extension;
ImageType imageType = await _context.ImageType.Where(i => i.ImageExtension == fileExtension).FirstOrDefaultAsync();
movieImage.ImageTypeId = imageType.Id;
// timestamp (note: not UTC for now)
movieImage.DateUploaded = DateTime.Now;
if (ModelState.IsValid)
{
_context.Add(movieImage);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ImageTypeId"] = new SelectList(_context.ImageType, "Id", "ImageExtension", movieImage.ImageTypeId);
ViewData["MovieId"] = new SelectList(_context.Movie, "Id", "Title", movieImage.MovieId);
return(View(movieImage));
}
public MovieImage InsertImage(MovieImage image)
{
_dbContext.Add(image);
_dbContext.SaveChanges();
return(image);
}
public MovieImage UpdateImage(MovieImage image)
{
_dbContext.Update(image);
_dbContext.SaveChanges();
return(image);
}
public async Task <IActionResult> Edit(long id, [Bind("Id,MovieId,ImageName,ImageTypeId,Description,FileContents,DateUploaded")] MovieImage movieImage)
{
if (id != movieImage.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movieImage);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieImageExists(movieImage.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ImageTypeId"] = new SelectList(_context.ImageType, "Id", "ImageExtension", movieImage.ImageTypeId);
ViewData["MovieId"] = new SelectList(_context.Movie, "Id", "Title", movieImage.MovieId);
return(View(movieImage));
}
/// <summary>
/// Parse image from html node
/// </summary>
/// <param name="node"></param>
/// <returns>Image</returns>
private MovieImage getImage(HtmlNode node)
{
string smallUrl = "";
string largeUrl = "";
string id = "";
try
{
string link = node.SelectNodes("div[@class='cover']")[0].SelectNodes("a")[0].Attributes["href"].Value.Trim();
int headerLength = people.id.Length + 7;
id = link.Substring(People.peopleLinkHeader.Length + headerLength, link.Length - headerLength - 1 - People.peopleLinkHeader.Length);
smallUrl = MovieImage.smallUrlHeader + id + ".jpg";
largeUrl = MovieImage.largeUrlHeader + id + ".jpg";
}
catch (Exception)
{
throw;
}
MovieImage image = new MovieImage();
image.id = id;
image.smallUrl = smallUrl;
image.largeUrl = largeUrl;
return(image);
}
public override User ParseGetUserDetailsResponse(string res)
{
XDocument doc = (System.Xml.Linq.XDocument)ToResponse(res);
var xmovies = doc.GetXElement("data");
User result = new User();
FillAbstractUser(xmovies, result);
FillUser(xmovies, result);
var xdlMovies = xmovies.GetXElements("item").ToList();
foreach (var xdlMovie in xdlMovies)
{
UserDownloadedMovie dl = new UserDownloadedMovie();
FillAbstractMovie(xdlMovie, dl);
result.Downloads.Add(dl);
MovieImage image;
image = new MovieImage()
{
Url = xdlMovie.Descendants("small_cover_image").First().GetXElementValue<string>(),
ImageSize = ImageSize.Small,
ImageType = MovieImageType.Cover
};
dl.Images.Add(image);
image = new MovieImage()
{
Url = xdlMovie.Descendants("medium_cover_image").First().GetXElementValue<string>(),
ImageSize = ImageSize.Medium,
ImageType = MovieImageType.Cover
};
dl.Images.Add(image);
}
return result;
}
public ActionResult Index(MovieImageViewModel model)
{
var img = Image.FromStream(model.File.InputStream, true, true);
var filename = Path.GetFileName(model.File.FileName);
var path = Path.Combine(Server.MapPath("~/Content/Photo/"), filename);
model.File.SaveAs(path);
MovieImage movie = new MovieImage
{
Id = Guid.NewGuid(),
ImgName = filename,
ImgPath = path,
Lenght = img.Height,
Width = img.Width
};
//unitOfWork.MovieImages.Add(movie);
_context.MovieImages.Add(movie);
_context.SaveChanges();
//unitOfWork.Complete();
return(View());
}
/// <summary>
/// Adds images to given movie
/// </summary>
/// <param name="images">List of image upload results</param>
/// <param name="movieId">Movie id</param>
public async Task AddMovieImages(IEnumerable <UploadedImage> images, Guid movieId)
{
var imagesToAdd = images.Select(i => new Image {
Url = i.Filepath
}).ToList();
for (int i = 0; i < imagesToAdd.Count; ++i)
{
await ImageRepo.CreateAsync(imagesToAdd[i]);
await ImageRepo.SaveChangesAsync();
}
var movieImages = new List <MovieImage>(imagesToAdd.Count());
foreach (var img in imagesToAdd)
{
var type = images.FirstOrDefault(i => i.Filepath == img.Url)?.ImageType;
var movieImage = new MovieImage
{
MovieId = movieId,
ImageType = type,
ImageId = img.Id
};
movieImages.Add(movieImage);
}
MovieImageRepo.AddRange(movieImages);
await MovieImageRepo.SaveChangesAsync();
}
public MovieDTO EditMovieImage(long id, byte[] imageBytes)
{
Movie movieToEdit = _moviesRepository.GetSingleMovie(id).FirstOrDefault();
if (movieToEdit == null)
{
throw new System.Exception("Object not found");
}
MovieImage editedImage = _imagesRepository.getImages().Where(p => p.MovieId == id).FirstOrDefault();
if (editedImage == null)
{
MovieImage imageToInsert = new MovieImage()
{
MovieId = id,
Image = imageBytes
};
editedImage = _imagesRepository.InsertImage(imageToInsert);
}
else
{
MovieImage imageToEdit = movieToEdit.Image;
imageToEdit.Image = imageBytes;
editedImage = _imagesRepository.UpdateImage(imageToEdit);
}
movieToEdit.Image = editedImage;
return(_mapper.Map <MovieDTO>(_moviesRepository.PatchMovie(movieToEdit)));
}
public static List <SuggestionMovie> ParseGetMovieSuggestionResponse(string response)
{
XDocument doc = LoadXDoc(response);
var xmovies = doc.GetXElement("data").GetXElements("movie_suggestion").ToList();
List <SuggestionMovie> movies = new List <SuggestionMovie>();
foreach (var item in xmovies)
{
SuggestionMovie movie = new SuggestionMovie();
FillAbstractMovie(item, movie);
movie.State = xmovies.Descendants("state").First().GetXElementValue <string>();
MovieImage image;
image = new MovieImage()
{
Url = xmovies.Descendants("small_cover_image").First().GetXElementValue <string>(),
ImageSize = ImageSize.Small,
ImageType = MovieImageType.Cover
};
movie.Images.Add(image);
image = new MovieImage()
{
Url = xmovies.Descendants("medium_cover_image").First().GetXElementValue <string>(),
ImageSize = ImageSize.Medium,
ImageType = MovieImageType.Cover
};
movie.Images.Add(image);
movies.Add(movie);
}
return(movies);
}
private async Task <MovieDetailsViewModel> GetMovieAsync(Expression <Func <Movie, bool> > movieSearchPredicate)
{
Movie movieGeneralDetails = await _context.Movie
.Include(m => m.DirectorFilmMember)
.Include(m => m.RestrictionRating)
.Include(m => m.MovieGenre)
.ThenInclude(mg => mg.Genre)
.Include(m => m.MovieLanguage)
.ThenInclude(ml => ml.LanguageIsoCodeNavigation)
.FirstOrDefaultAsync(movieSearchPredicate);
long movieId = movieGeneralDetails.Id;
int numberUserReviews = await _context.MovieUserReview.Where(m => m.MovieId == movieId).CountAsync();
using var sqlConn = new SqlConnection(_context.Database.GetDbConnection().ConnectionString);
DataTable dtMovieCastAndCrew = GetMovieCastAndCrew(sqlConn, movieId);
List <MovieCastMemberDetail> castMembers = GetCastMembers(dtMovieCastAndCrew);
List <MovieCrewMemberDetail> crewMembers = GetCrewMembers(dtMovieCastAndCrew);
List <VwAwardWinnerInfo> awards = await _context.VwAwardWinnerInfo.Where(w => w.MovieId == movieId).ToListAsync();
var awardInformation = awards.Select(a => new AwardInfo()
{
AwardId = a.AwardId,
AwardName = a.AwardName,
PreferredFullName = a.PreferredFullName,
ShowName = a.ShowName,
Year = a.Year
}).ToList();
MovieImage topImage = await _context.MovieImage.Include(m => m.ImageType).Where(m => m.MovieId == movieId)
.OrderByDescending(m => m.DateUploaded).FirstOrDefaultAsync();
var viewModel = new MovieDetailsViewModel()
{
Title = movieGeneralDetails.Title,
Description = movieGeneralDetails.Description,
ReleaseDate = movieGeneralDetails.ReleaseDate,
RestrictionRating = movieGeneralDetails.RestrictionRating?.Code,
DirectorFilmMemberId = movieGeneralDetails.DirectorFilmMemberId,
DirectorName = movieGeneralDetails.DirectorFilmMember?.PreferredFullName,
Duration = $"{movieGeneralDetails.DurationInMinutes} mins",
AverageUserRating = movieGeneralDetails.AverageUserRating,
Languages = string.Join(", ", movieGeneralDetails.MovieLanguage.Select(l => l.LanguageIsoCodeNavigation !.LanguageName)),
Genres = string.Join(", ", movieGeneralDetails.MovieGenre.Select(g => g.Genre !.GenreName)),
Image = topImage,
NumberOfUserRatings = numberUserReviews,
MovieCastMembers = castMembers,
MovieCrewMembers = crewMembers,
AwardDetails = awardInformation,
};
return(viewModel);
}
private void StoreMovieImage(Stream movieImageStream)
{
byte[] photoBytes = new byte[movieImageStream.Length];
movieImageStream.Read(photoBytes, 0, photoBytes.Length);
MovieImage image = new MovieImage();
image.ImageData = new Binary(photoBytes);
this.selectedMovie.Images.Add(image);
App.DB.SubmitChanges();
}
/// <summary>
/// Downloads images in "original" size and saves them to cache.
/// </summary>
/// <param name="image">Image to download</param>
/// <param name="category">Image category (Poster, Cover, Backdrop...)</param>
/// <returns><c>true</c> if successful</returns>
public bool DownloadImage(MovieImage image, string category)
{
string cacheFileName = CreateAndGetCacheName(image, category);
if (string.IsNullOrEmpty(cacheFileName))
{
return(false);
}
string sourceUri = Configuration.Images.BaseUrl + "original" + image.FilePath;
_downloader.DownloadFile(sourceUri, cacheFileName);
return(true);
}
/// <summary>
/// Adds image to given movie
/// </summary>
/// <param name="url">Image location</param>
/// <param name="movieId">Movie id</param>
/// <param name="type">Image type</param>
public async Task AddMovieImage(string url, Guid movieId, MovieImageTypeEnum type)
{
var image = new Image {
Url = url
};
await ImageRepo.CreateAsync(image);
await ImageRepo.SaveChangesAsync();
var movieImage = new MovieImage {
ImageId = image.Id, MovieId = movieId, ImageType = MovieImageType.ToStr(type)
};
await MovieImageRepo.CreateAsync(movieImage);
await MovieImageRepo.SaveChangesAsync();
}
private MovieImage CreateMovieImage(HttpPostedFileBase imageFile)
{
var movieImage = new MovieImage();
using (var ms = new MemoryStream())
{
imageFile.InputStream.CopyTo(ms);
movieImage.Image = ms.ToArray();
}
_context.MovieImages.Add(movieImage);
_context.SaveChanges();
_context.Entry(movieImage).GetDatabaseValues();
return(movieImage);
}
/// <summary>
/// Creates a local file name for loading and saving <see cref="MovieImage"/>s.
/// </summary>
/// <param name="image"></param>
/// <param name="category"></param>
/// <returns>Cache file name or <c>null</c> if directory could not be created</returns>
protected string CreateAndGetCacheName(MovieImage image, string category)
{
try
{
string folder = Path.Combine(_cachePath, string.Format(@"{0}\{1}", image.MovieId, category));
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
return(Path.Combine(folder, image.FilePath.TrimStart(new[] { '/' })));
}
catch
{
// TODO: logging
return(null);
}
}
public async Task <IActionResult> UploadFile([FromForm] MovieImage movie)
{
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Expected a multipart request, but got {Request.ContentType}"));
}
try
{
using (var stream = movie.Image.OpenReadStream())
{
var cloudBlock = await UploadToBlob(movie.Image.FileName, null, stream);
//// Retrieve the filename of the file you have uploaded
//var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(cloudBlock.StorageUri.ToString()))
{
return(BadRequest("An error has occured while uploading your file. Please try again."));
}
MovieItem movieItem = new MovieItem();
movieItem.Title = movie.Title;
movieItem.Playtime = movie.Playtime;
movieItem.Genre = movie.Genre;
movieItem.Rating = movie.Rating;
movieItem.Trailer = movie.Trailer;
System.Drawing.Image image = System.Drawing.Image.FromStream(stream);
movieItem.Height = image.Height.ToString();
movieItem.Width = image.Width.ToString();
movieItem.Url = cloudBlock.SnapshotQualifiedUri.AbsoluteUri;
movieItem.Uploaded = DateTime.Now.ToString();
_context.MovieItem.Add(movieItem);
await _context.SaveChangesAsync();
return(Ok($"File: {movie.Title} has successfully uploaded"));
}
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Details: {ex.Message}"));
}
}
public override List<ListMovie> ParseListMovieResponse(string response)
{
XDocument doc = (System.Xml.Linq.XDocument)ToResponse(response);
var dataElement = doc.GetXElement("data");
if (dataElement == null || dataElement.Descendants().Count() == 0)
return new List<ListMovie>();
var xmovies = dataElement.GetXElements("movie").ToList();
List<ListMovie> movies = new List<ListMovie>();
foreach (XElement xmovie in xmovies)
{
ListMovie movie = new ListMovie();
FillAbstractYifyMovie(xmovie, movie);
movie.State = xmovie.Descendants("state").First().GetXElementValue<string>();
MovieImage image;
image = new MovieImage()
{
Url = xmovie.Descendants("small_cover_image").First().GetXElementValue<string>(),
ImageSize = ImageSize.Small,
ImageType = MovieImageType.Cover
};
movie.Images.Add(image);
image = new MovieImage()
{
Url = xmovie.Descendants("medium_cover_image").First().GetXElementValue<string>(),
ImageSize = ImageSize.Medium,
ImageType = MovieImageType.Cover
};
movie.Images.Add(image);
movies.Add(movie);
}
return movies;
}
public ActionResult Create(MovieViewModel model)
{
var movie = new Movie();
var img = Image.FromStream(model.File.InputStream, true, true);
var filename = Path.GetFileName(model.File.FileName);
if (filename != null)
{
var path = Path.Combine(Server.MapPath("~/Content/Photo/"), filename);
model.File.SaveAs(path);
var movieImg = new MovieImage
{
Id = Guid.NewGuid(),
ImgName = filename,
ImgPath = path,
Lenght = img.Height,
Width = img.Width
};
_context.MovieImages.Add(movieImg);
_context.SaveChanges();
movie.Id = Guid.NewGuid();
movie.Name = model.Name;
movie.TrailerLink = model.TrailerLink;
movie.PremiereDate = model.PremiereDate;
movie.Lenght = model.Lenght_min;
movie.Description = model.Description;
movie.MovieImageId = movieImg.Id;
movie.ClasificationId = model.ClasificationId;
movie.MovieFormatId = model.MovieFormatId;
}
_context.Movies.Add(movie);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult SubAddMovie(Movie obj, MovieImage temp)
{
MovieDal dal = new MovieDal();
string Hallid = obj.HallId.ToString();
string date = obj.date.ToString();
string time = obj.time.ToString();
List <Movie> exist = (from x in dal.Movies where x.HallId.Equals(Hallid) && x.date.Equals(date) && x.time.Equals(time) select x).ToList <Movie>();
if (exist.Count != 0)
{
TempData["msg"] = "There is a movie at the same time and the same hall !!!";
TempData["color"] = "red";
return(View("AddMovie", obj));
}
HallDal halls = new HallDal();
List <Hall> HallExist = (from x in halls.Halls where x.HallId.Equals(obj.HallId) select x).ToList <Hall>();
if (HallExist.Count == 0)
{
TempData["msg"] = "Hall not exist !!!";
TempData["color"] = "red";
return(View("AddMovie", obj));
}
string filename = Path.GetFileNameWithoutExtension(temp.ImageBytes.FileName);
string extension = Path.GetExtension(temp.ImageBytes.FileName);
filename = filename + DateTime.Now.ToString("yymmssfff") + extension;
obj.poster = "~/Images/" + filename;
filename = Path.Combine(Server.MapPath("~/Images/"), filename);
temp.ImageBytes.SaveAs(filename);
dal.Movies.Add(obj);
dal.SaveChanges();
TempData["msg"] = "Movie Added Successfully !!!";
TempData["color"] = "blue";
return(View("AddMovie"));
}
public override List<BookmarkedMovie> ParseGetBookmarkedMoviesResponse(string res)
{
XDocument doc = (System.Xml.Linq.XDocument)ToResponse(res);
var xmovies = doc.GetXElement("data").GetXElements("movie").ToList();
List<BookmarkedMovie> result = new List<BookmarkedMovie>();
foreach (var item in xmovies)
{
BookmarkedMovie bm = new BookmarkedMovie();
FillAbstractYifyMovie(item, bm);
MovieImage image;
image = new MovieImage()
{
Url = item.Descendants("small_cover_image").First().GetXElementValue<string>(),
ImageSize = ImageSize.Small,
ImageType = MovieImageType.Cover
};
bm.Images.Add(image);
image = new MovieImage()
{
Url = item.Descendants("medium_cover_image").First().GetXElementValue<string>(),
ImageSize = ImageSize.Medium,
ImageType = MovieImageType.Cover
};
bm.Images.Add(image);
bm.State = item.GetXDecendentValue<string>("state");
bm.RTAudienceRating = item.GetXDecendentValue<string>("rt_audience_rating");
bm.RTAudienceScore = item.GetXDecendentValue<int>("rt_audience_score");
bm.RTCriticsRating = item.GetXDecendentValue<string>("rt_critics_rating");
bm.RTCriticsScore = item.GetXDecendentValue<int>("rt_critics_score");
result.Add(bm);
}
return result;
}
/// <summary>
/// Get image from html node
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
private MovieImage getImage(HtmlNode node)
{
string smallUrl = "";
string largeUrl = "";
string id = "";
try
{
string link = node.SelectNodes("a")[0].Attributes["href"].Value.Trim();
id = link.Substring(Movie.homePage.Length + 14, link.Length - 15 - Movie.homePage.Length);
smallUrl = MovieImage.smallUrlHeader + id + ".jpg";
largeUrl = MovieImage.largeUrlHeader + id + ".jpg";
}
catch (Exception)
{
throw;
}
MovieImage image = new MovieImage();
image.id = id;
image.smallUrl = smallUrl;
image.largeUrl = largeUrl;
return(image);
}
public Movie FetchMovie(string id, string metadataPath)
{
// Query TMDB for movie info by ID.
Movie m = new Movie();
string fetchUrl = TMDB_COMMAND_URL;
fetchUrl = fetchUrl.Replace("{cmd}", "Movie.getInfo");
fetchUrl = fetchUrl.Replace("{lang}", m_language);
fetchUrl = fetchUrl.Replace("{key}", m_apiKey);
fetchUrl += id;
// Fetch and parse results.
XDocument infoPage = XDocument.Load(fetchUrl);
XElement movieElem = infoPage.Root.Element("movies").Element("movie");
m.ID = movieElem.Element("id").Value;
m.Name = movieElem.Element("name").Value;
m.Certification = movieElem.Element("certification").Value;
m.Overview = movieElem.Element("overview").Value;
m.Genre = movieElem.Element("categories").Descendants("category").First().Attribute("name").Value;
m.Runtime = int.Parse(movieElem.Element("runtime").Value);
m.Released = null;
string released = movieElem.Element("released").Value;
if (!string.IsNullOrEmpty(released))
m.Released = DateTime.Parse(released);
// Fetch first image specified.
if (movieElem.Descendants("images").Count() > 0)
{
XElement imageElem = movieElem.Element("images").Descendants().First();
// Download the image to the movie's metadata directory.
string url = imageElem.Attribute("url").Value;
string path = metadataPath + "\\" + url.Substring(url.LastIndexOf('/') + 1);
WebClient wc = new WebClient();
wc.DownloadFile(url, path);
MovieImage mi = new MovieImage();
mi.type = (MovieImageType)Enum.Parse(typeof(MovieImageType), imageElem.Attribute("type").Value, true);
mi.width = uint.Parse(imageElem.Attribute("width").Value);
mi.height = uint.Parse(imageElem.Attribute("height").Value);
mi.path = path;
m.Images.Add(mi);
}
return m;
}
public ImageCommentHtmlParser(MovieImage image)
{
movieImage = image;
commentCollection = new ObservableCollection <Comment>();
hasMoreComments = false;
}
private static void FillMovieImages(XElement ele, Movie m)
{
MovieImage i = new MovieImage();
i.ImageSize = ImageSize.NotRelevent;
i.ImageType = MovieImageType.Background;
i.Url = ele.GetXDecendentValue<string>("background_image");
m.Images.Add(i);
var xElemList = ele.Descendants().ToList();
var xFilteredImgList = xElemList.Where(ximg => ximg.Name.LocalName.Contains("small"));
foreach (var item in xFilteredImgList)
{
i = new MovieImage()
{
ImageSize = ImageSize.Small,
Url = item.GetXElementValue<string>()
};
if (item.Name.LocalName.Contains("cover"))
i.ImageType = MovieImageType.Cover;
else if (item.Name.LocalName.Contains("screenshot"))
i.ImageType = MovieImageType.ScreenShot;
m.Images.Add(i);
}
xFilteredImgList = xElemList.Where(ximg => ximg.Name.LocalName.Contains("medium"));
foreach (var item in xFilteredImgList)
{
i = new MovieImage()
{
ImageSize = ImageSize.Medium,
Url = item.GetXElementValue<string>()
};
if (item.Name.LocalName.Contains("cover"))
i.ImageType = MovieImageType.Cover;
else if (item.Name.LocalName.Contains("screenshot"))
i.ImageType = MovieImageType.ScreenShot;
m.Images.Add(i);
}
xFilteredImgList = xElemList.Where(ximg => ximg.Name.LocalName.Contains("large"));
foreach (var item in xFilteredImgList)
{
i = new MovieImage()
{
ImageSize = ImageSize.Large,
Url = item.GetXElementValue<string>()
};
if (item.Name.LocalName.Contains("cover"))
i.ImageType = MovieImageType.Cover;
else if (item.Name.LocalName.Contains("screenshot"))
i.ImageType = MovieImageType.ScreenShot;
m.Images.Add(i);
}
}
private static void FillMovieImages(JToken ele, List <MovieImage> images)
{
MovieImage mi = new MovieImage();
var elems = ele.Where(i =>
i.Type == JTokenType.Property &&
i.ToObject <JProperty>().Name.Contains("large_screenshot")).ToList();
foreach (var item in elems)
{
try
{
mi = new MovieImage()
{
ImageSize = ImageSize.Large,
ImageType = MovieImageType.ScreenShot,
Url = item.First().Value <string>()
};
images.Add(mi);
}
catch (Exception) { }
}
elems = ele.Where(i =>
i.Type == JTokenType.Property &&
i.ToObject <JProperty>().Name.Contains("medium_screenshot")).ToList();
foreach (var item in elems)
{
try
{
mi = new MovieImage()
{
ImageSize = ImageSize.Medium,
ImageType = MovieImageType.ScreenShot,
Url = item.First().Value <string>()
};
images.Add(mi);
}
catch (Exception) { }
}
elems = ele.Where(i =>
i.Type == JTokenType.Property &&
i.ToObject <JProperty>().Name.Contains("cover")).ToList();
foreach (var item in elems)
{
try
{
mi = new MovieImage()
{
ImageType = MovieImageType.Cover,
Url = item.First().Value <string>()
};
if (item.ToObject <JProperty>().Name.Contains("large"))
{
mi.ImageSize = ImageSize.Large;
}
else if (item.ToObject <JProperty>().Name.Contains("small"))
{
mi.ImageSize = ImageSize.Small;
}
else
{
mi.ImageSize = ImageSize.Medium;
}
images.Add(mi);
}
catch (Exception) { }
}
elems = ele.Where(i =>
i.Type == JTokenType.Property &&
i.ToObject <JProperty>().Name.Contains("background")).ToList();
foreach (var item in elems)
{
try
{
mi = new MovieImage()
{
ImageType = MovieImageType.Background,
Url = item.First().Value <string>()
};
if (item.ToObject <JProperty>().Name.Contains("large"))
{
mi.ImageSize = ImageSize.Large;
}
else if (item.ToObject <JProperty>().Name.Contains("small"))
{
mi.ImageSize = ImageSize.Small;
}
else
{
mi.ImageSize = ImageSize.Medium;
}
images.Add(mi);
}
catch (Exception) { }
}
}
public override List <Data.ListMovie> ParseListMovieResponse(string response)
{
var jsonDoc = (JObject)ToResponse(response);
var count = jsonDoc["data"]["movie_count"].Value <int>();
List <JToken> moviesJtkn;
if (count == 0)
{
return(new List <ListMovie>());
}
else
{
moviesJtkn = jsonDoc["data"]["movies"].ToList();
}
List <ListMovie> movies = new List <ListMovie>();
foreach (JToken xmovie in moviesJtkn)
{
ListMovie movie = new ListMovie();
FillAbstractYifyMovie(xmovie, movie);
movie.State = xmovie["state"].Value <string>();
MovieImage image;
try
{
image = new MovieImage()
{
Url = xmovie["small_cover_image"].Value <string>(),
ImageSize = ImageSize.Small,
ImageType = MovieImageType.Cover
};
movie.Images.Add(image);
}
catch (Exception) { }
try
{
image = new MovieImage()
{
Url = xmovie["medium_cover_image"].Value <string>(),
ImageSize = ImageSize.Medium,
ImageType = MovieImageType.Cover
};
movie.Images.Add(image);
}
catch (Exception) { }
try
{
image = new MovieImage()
{
Url = xmovie["large_cover_image"].Value <string>(),
ImageSize = ImageSize.Large,
ImageType = MovieImageType.Cover
};
movie.Images.Add(image);
}
catch (Exception) { }
try
{
image = new MovieImage()
{
Url = xmovie["background_image"].Value <string>(),
ImageSize = ImageSize.NotRelevent,
ImageType = MovieImageType.Background
};
movie.Images.Add(image);
}
catch (Exception) { }
try
{
image = new MovieImage()
{
Url = xmovie["background_image_original"].Value <string>(),
ImageSize = ImageSize.NotRelevent,
ImageType = MovieImageType.Background
};
movie.Images.Add(image);
}
catch (Exception) { }
movies.Add(movie);
}
return(movies);
}
public bool DownloadImage(MovieImage image, string category)
{
return(_movieDbHandler.DownloadImage(image, category));
}
