private static MovieGenre RegisterGenre(int id, string name)
{
var genre = new MovieGenre(id, name);
_movieGenres.Add(id, genre);
return(genre);
}
/// <summary>
/// Assigns an Genre to a Movie in the database.
/// Adds the Genre to the database if it does not exist.
/// Returns true if successful; false otherwise.
/// </summary>
/// <param name="movieGenreName"></param>
/// <returns></returns>
public bool AddMovieGenre(string movieId, string movieGenreName)
{
if (!MovieExists(movieId))
{
return(false);
}
if (!GenreExists(movieGenreName))
{
Genre newGenre = new Genre();
newGenre.GenreName = movieGenreName;
AddGenre(newGenre);
}
Genre genre = GetGenre(movieGenreName);
if (genre == null)
{
return(false);
}
MovieGenre movieGenre = new MovieGenre();
movieGenre.ImdbId = movieId;
movieGenre.GenreId = genre.GenreId;
_dbContext.MovieGenres.Add(movieGenre);
_dbContext.SaveChanges();
return(true);
}
public async Task <IActionResult> AddGenres(TheMovieDb theMovieDb, int movieId)
{
foreach (var gId in theMovieDb.Genre_ids)
{
string genreName = await GetGenreNameById((Int64)gId);
MovieGenre mg = await _dbContext.MovieGenres
.Where(mg => mg.Name == genreName)
.FirstOrDefaultAsync();
Movie movie = await _dbContext.Movies
.Where(m => m.Name == theMovieDb.Original_title)
.FirstOrDefaultAsync();
GenreMovieLink gml = new GenreMovieLink
{
MovieId = movie.Id,
MovieGenreId = mg.Id
};
_dbContext.GenreMovieLinks.Add(gml);
await _dbContext.SaveChangesAsync();
}
return(RedirectToAction("HomeAdmin", "Administrator"));
}
public bool update(int movieId, MovieRequest request)
{
var originalModel = _context.movies.Include(x => x.movieGenres).FirstOrDefault(m => m.id.Equals(movieId));
var parsedModel = new Movie
{
title = request.title,
releaseYear = request.releaseYear,
};
if (originalModel is null)
{
throw new Exception("Model not found");
}
foreach (var genre in _context.genres.Where(g => request.genresIds.Contains(g.id)))
{
var movieGenre = new MovieGenre
{
genre = genre,
movie = parsedModel
};
parsedModel.movieGenres.Add(movieGenre);
}
originalModel.releaseYear = parsedModel.releaseYear;
originalModel.title = parsedModel.title;
originalModel.movieGenres = parsedModel.movieGenres;
_context.movies.Update(originalModel);
return(_context.SaveChanges() > 0);
}
// GET: Movies
public ActionResult Index(string sortParam, string sortOrder, string genre, string countryProduction, string years, int?pageSize, int?page)
{
IEnumerable <Movie> movies = db.Movies.Include(m => m.Genre).Include(m => m.MovieInfo).Include(m => m.UserRates).ToList();
//lista lat z dostepnych filmow
ViewBag.Years = new SelectList(movies.OrderBy(m => m.ReleaseDate.Year).Select(m => m.ReleaseDate.Year).Distinct().ToList(), years);
//listy sortujacefiltrujace
ViewBag.SortParam = new SelectList(new[] { "Tytułu", "Daty premiery", "Oceny" }, sortParam);
ViewBag.SortOrder = new SelectList(SortOrder(), sortOrder);
ViewBag.Genre = new SelectList(MovieGenre.GetTypes(), genre);
ViewBag.CountryProduction = new SelectList(CountryList(), countryProduction);
ViewBag.PageSize = new SelectList(PageSizes(), pageSize);
ViewBag.NoContent = "Brak filmów spełniających warunek :(";
int pagesize = (pageSize ?? DefPageSize);
int pageNumber = (page ?? DefPageNo);
movies = SwitchGenre(movies, genre);
movies = FilterCountry(movies, countryProduction);
movies = FilterYears(movies, years);
movies = SortMovies(movies, sortParam, sortOrder);
if (Request.IsAjaxRequest())
{
return(PartialView("_TileList", movies.ToPagedList(pageNumber, pagesize)));
}
return(View(movies.ToPagedList(pageNumber, pagesize)));
}
public void AddNew(int movieID, int genreID)
{
movieGenre = IfExist(movieID, genreID);
// TODO: трябва да се добави добавяне на нов жанр и филм, малко по-късно ще го оправя
if (movieGenre != null)
{
if (movieGenre.IsDeleted)
{
movieGenre.IsDeleted = false;
this.unitOfWork.SaveChanges();
return;
}
throw new EntityAlreadyExistsException($"Movie Genre combination is already present in database.");
}
else
{
movieGenre = new MovieGenre()
{
MovieId = movieID,
GenreId = genreID
};
this.unitOfWork.MovieGenres.Add(movieGenre);
this.unitOfWork.SaveChanges();
}
}
public static List <MovieGenre> GetMovieGenres()
{
List <MovieGenre> genreList = new List <MovieGenre>();
SqlConnection sqlConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["MasterCinemaConnection"].ConnectionString);
SqlCommand selectCommand = new SqlCommand("SELECT ID, Name FROM MovieGenre");
selectCommand.Connection = sqlConnection;
try
{
if (sqlConnection.State == System.Data.ConnectionState.Closed)
{
sqlConnection.Open();
}
SqlDataReader dataReader = selectCommand.ExecuteReader();
MovieGenre genre;
while (dataReader.Read())
{
genre = new MovieGenre();
genre.ID = (int)dataReader["ID"];
genre.Name = (string)dataReader["Name"];
genreList.Add(genre);
}
}
catch (Exception) { throw; }
finally { sqlConnection.Close(); }
return(genreList);
}
/// <summary>
/// Ermittelt die Liste der Genres für den Movie und fügt diejenigen hinzu, deren Name noch nicht in der
/// übergebenen Liste enthalten ist
/// Es werden keine Genres entfernt
/// Typische Anwednung: Bei Selektion eines Movie von einem Provider werden Genrenamen mitgeliefert, die
/// dann dem Film hinzugefügt werden sollen
/// </summary>
/// <param name="movie">Film, dessen Genres erweitert werden sollem</param>
/// <param name="genreNames">Namen der hinzuzufügenden Genres</param>
/// <returns>Alle MovieGenres für den Film, also alte sowie neu hinzugefügte</returns>
public async Task <ICollection <MovieGenre> > AddMovieGenres(Movie movie, IList <string> genreNames)
{
List <MovieGenre> movieGenres = new List <MovieGenre>();
IGenreService genreService = Resolver.Resolve <IGenreService>();
// Bestimmen der Genres, die dem Film neu zugeordnet werden müssen
var existingGenres = movie.MovieGenres.Where(x => x.Movie == movie).Select(mg => mg.Genre);
var existingGenreNames = existingGenres.Select(s => s.Name);
var newGenreNames = (from genre in genreNames select genre).Except(from existingGenre in existingGenreNames select existingGenre);
foreach (string genreName in newGenreNames)
{
// Genres anlegen, falls es noch nicht existiert
Genre genre = await genreService.GetOrCreateGenre(genreName);
MovieGenre movieGenre = MovieGenre.CreateNew <MovieGenre>();
movieGenre.Movie = movie;
movieGenre.Genre = genre;
movieGenres.Add(movieGenre);
}
// Auch die bereits vorhandenen, zugeordneten Genres zurückgeben, damit diese angezeigt werden
movieGenres.AddRange(movie.MovieGenres);
return(movieGenres);
}
private void GenreSelectionChangedHandler(GenreSelection genreSelection)
{
MovieGenre movieGenre = Movie.MovieGenres.Where(mg => mg.Genre.Id == genreSelection.Genre.Id).FirstOrDefault();
if (genreSelection.Selected)
{
if (movieGenre == null)
{
movieGenre = MovieGenre.CreateNew <MovieGenre>();
movieGenre.Genre = genreSelection.Genre;
movieGenre.Movie = Movie;
Movie.MovieGenres.Add(movieGenre);
OnGenreSelectionChanged?.Invoke(genreSelection);
}
else if (movieGenre.IsDeleted)
{
movieGenre.IsDeleted = false;
}
}
else if (movieGenre != null)
{
// Wird ein Genre abgewählt, dass noch nicht gespeichert war, kann es einfach aus der Liste entfernt werden.
// War es schon gespeichert, muss es auf Deleted gesetzt werden, damit das Delete in der DB stattfinden kann.
if (movieGenre.IsNew)
{
Movie.MovieGenres.Remove(movieGenre);
}
else
{
movieGenre.IsDeleted = true;
}
OnGenreSelectionChanged?.Invoke(genreSelection);
}
}
public MovieGenre Create(MovieGenre MovieGenre)
{
var result = context.Add <MovieGenre>(MovieGenre);
context.SaveChanges();
return(result.Entity);
}
public async Task <IActionResult> PutMovieGenre(int id, MovieGenre movieGenre)
{
if (id != movieGenre.movieId)
{
return(BadRequest());
}
_context.Entry(movieGenre).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieGenreExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
// To protect from overposting attacks, enable the specific properties you want to bind to, for
// more details, see https://aka.ms/RazorPagesCRUD.
public async Task <IActionResult> OnPostAsync(string[] selectedGenres)
{
var newMovie = new Movie();
if (selectedGenres != null)
{
newMovie.MovieGenres = new List <MovieGenre>();
foreach (var gen in selectedGenres)
{
var genToAdd = new MovieGenre
{
GenreID = int.Parse(gen)
};
newMovie.MovieGenres.Add(genToAdd);
}
}
if (await TryUpdateModelAsync <Movie>(
newMovie,
"Movie",
i => i.Title, i => i.Director,
i => i.IMDBRatings, i => i.ReleaseDate, i => i.ProductionCoID, i => i.StarID))
{
_context.Movie.Add(newMovie);
await _context.SaveChangesAsync();
return(RedirectToPage("./Index"));
}
PopulateAssignedGenreData(_context, newMovie);
return(Page());
}
public ActionResult Create(Movie movie)
{
if (!ModelState.IsValid)
{
var viewModel = new MovieGenre(movie)
{
Genre = _context.Genres.ToList()
};
return(View("New", viewModel));
}
if (movie.Id == 0)
{
movie.DateAdded = DateTime.Now;
_context.Movies.Add(movie);
}
else
{
var UpdateDB = _context.Movies.Single(c => c.Id == movie.Id);
UpdateDB.Name = movie.Name;
UpdateDB.ReleazeDate = movie.ReleazeDate;
UpdateDB.NumberInStock = movie.NumberInStock;
UpdateDB.GenreId = movie.GenreId;
}
_context.SaveChanges();
return(RedirectToAction("Index", "Movies"));
}
public MovieGenre Delete(MovieGenre MovieGenre)
{
var result = context.Remove(MovieGenre);
context.SaveChanges();
return(result.Entity);
}
/// <summary>
/// Get the favorites movies
/// </summary>
/// <returns>Favorites movies</returns>
public async Task<IEnumerable<MovieShort>> GetFavoritesMoviesAsync(MovieGenre genre = null)
{
var watch = Stopwatch.StartNew();
var movies = new List<MovieShort>();
await Task.Run(async () =>
{
using (var context = new ApplicationDbContext())
{
await context.MovieHistory.LoadAsync();
var movieHistory = await context.MovieHistory.FirstOrDefaultAsync();
if (genre != null)
{
movies.AddRange(movieHistory.MoviesShort.Where(
p => p.IsFavorite && p.Genres.Any(g => g.Name == genre.EnglishName))
.Select(MovieShortFromEntityToModel));
}
else
{
movies.AddRange(movieHistory.MoviesShort.Where(
p => p.IsFavorite)
.Select(MovieShortFromEntityToModel));
}
}
});
watch.Stop();
var elapsedMs = watch.ElapsedMilliseconds;
Logger.Debug(
$"GetFavoritesMoviesIdAsync in {elapsedMs} milliseconds.");
return movies;
}
//public async Task<IEnumerable<MovieResponseModel>> GetMoviesByGenre(int genreId)
//{
// var movies = await _movieRepository.GetMoviesByGenre(genreId);
// if (!movies.Any()) throw new NotFoundException("Movies for genre", genreId);
// var response = _mapper.Map<IEnumerable<MovieResponseModel>>(movies);
// return response;
//}
public async Task <MovieDetailsResponseModel> CreateMovie(MovieCreateRequest movieCreateRequest)
{
//if (_currentUserService.UserId != favoriteRequest.UserId)
// throw new HttpException(HttpStatusCode.Unauthorized, "You are not Authorized to purchase");
// check whether the user is Admin and can create the movie claim
var movie = _mapper.Map <Movie>(movieCreateRequest);
var createdMovie = await _movieRepository.AddAsync(movie);
// var movieGenres = new List<MovieGenre>();
foreach (var genre in movieCreateRequest.Genres)
{
var movieGenre = new MovieGenre {
MovieId = createdMovie.Id, GenreId = genre.Id
};
//await _genresRepository.AddAsync(movieGenre);
var genresddd = _genresRepository.GetByIdAsync(movieGenre.GenreId);
await _genresRepository.AddAsync(genresddd.Result);
}
return(_mapper.Map <MovieDetailsResponseModel>(createdMovie));
//throw new NotImplementedException();
}
public async Task <ImmutableList <Domain.Movie> > GetMoviesByGenre(MovieGenre genre)
{
// get movies from external api
var movies = await _externalMovieApiServices.GetMoviesByGenre(genre);
return(SaveNotSavedMovies(movies));
}
private static void AddMovie(MovieContext context, Movie movie, String[] genreText)
{
// add movie to Movies table
context.Movies.Add(movie);
foreach (var gt in genreText)
{
if (gt.ToLower() != "(no genres listed)")
{
MovieGenre mg = new MovieGenre()
{
Movie = movie
};
// only add unique genres to Genres table
if (!context.Genres.Local.Any(g => g.GenreText == gt))
{
Genre genre = new Genre()
{
GenreText = gt
};
context.Genres.Add(genre);
mg.Genre = genre;
}
else
{
Genre genre = context.Genres.Local.FirstOrDefault(g => g.GenreText == gt);
mg.Genre = genre;
}
// add all movie genres to MovieGenres table
context.MovieGenres.Add(mg);
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("MovieGenreId,Name,CreationDate,Active")] MovieGenre MovieGenre)
{
if (id != MovieGenre.MovieGenreId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(MovieGenre);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieGenreExists(MovieGenre.MovieGenreId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(MovieGenre));
}
public void EditAMovie(int id, string name, double onlinePrice, double bluRayPrice, double dvdPrice,
string description, string directors, MovieGenre genre, MovieGenre?genre2,
MovieGenre?genre3, DateTime releaseDate, int length, double imdbScore,
int rottenTomatoes, string imdbUrl, string posterUrl,
string trailerUrl)
{
this.db.Movies.FirstOrDefault(m => m.Id == id).Name = name;
this.db.Movies.FirstOrDefault(m => m.Id == id).OnlinePrice = onlinePrice;
this.db.Movies.FirstOrDefault(m => m.Id == id).BluRayPrice = bluRayPrice;
this.db.Movies.FirstOrDefault(m => m.Id == id).DvdPrice = dvdPrice;
this.db.Movies.FirstOrDefault(m => m.Id == id).Description = description;
this.db.Movies.FirstOrDefault(m => m.Id == id).Directors = directors;
this.db.Movies.FirstOrDefault(m => m.Id == id).Genre = genre;
this.db.Movies.FirstOrDefault(m => m.Id == id).Genre2 = (MovieGenre)genre2;
this.db.Movies.FirstOrDefault(m => m.Id == id).Genre3 = (MovieGenre)genre3;
this.db.Movies.FirstOrDefault(m => m.Id == id).ReleaseDate = releaseDate;
this.db.Movies.FirstOrDefault(m => m.Id == id).Length = length;
this.db.Movies.FirstOrDefault(m => m.Id == id).IMDbScore = imdbScore;
this.db.Movies.FirstOrDefault(m => m.Id == id).RottenTomatoes = rottenTomatoes;
this.db.Movies.FirstOrDefault(m => m.Id == id).IMDbUrl = imdbUrl;
this.db.Movies.FirstOrDefault(m => m.Id == id).PosterUrl = posterUrl;
this.db.Movies.FirstOrDefault(m => m.Id == id).TrailerUrl = trailerUrl;
this.db.SaveChanges();
}
public Movie(string title, MovieGenre genere, byte rating, double ticketPrice)
{
Title = title;
Genere = genere;
try
{
if (rating < 1 || rating > 5)
{
throw new Exception("Invalid rating range!");
}
Rating = rating;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine("Rating should be from 1 to 5");
Console.WriteLine("Rating is set to 1");
Rating = 1;
}
if (ticketPrice == 0)
{
TicketPrice = 5 * rating;
}
else
{
TicketPrice = ticketPrice;
}
}
public MoviePoco Map(MovieTmdb movieTmdb, MovieOmdb movieOmdb)
{
var movieGenres = new List <MovieGenre>();
foreach (var genre in movieTmdb.Genres)
{
var movieGenre = new MovieGenre
{
Title = movieOmdb.Title,
Released = movieOmdb.Released,
GenreId = genre.Id
};
movieGenres.Add(movieGenre);
}
var movie = new MoviePoco
{
Title = movieOmdb.Title,
Released = movieOmdb.Released,
ImdbRating = movieOmdb.ImdbRating,
Metascore = movieOmdb.Metascore,
TomatoMeter = movieOmdb.TomatoMeter,
ImdbVotes = movieOmdb.ImdbVotes,
Runtime = movieOmdb.Runtime,
Plot = movieOmdb.Plot,
Director = movieOmdb.Director,
Awards = movieOmdb.Awards,
MovieGenres = movieGenres
};
return(movie);
}
public async Task <IActionResult> Edit(int id, [Bind("MovieId,GenreId")] MovieGenre movieGenre)
{
if (id != movieGenre.MovieId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movieGenre);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieGenreExists(movieGenre.MovieId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["GenreId"] = new SelectList(_context.Genres, "GenreId", "GenreId", movieGenre.GenreId);
ViewData["MovieId"] = new SelectList(_context.Movies, "MovieId", "MovieId", movieGenre.MovieId);
return(View(movieGenre));
}
public IActionResult EditGenre(int id, SeriesViewViewModel model)
{
Series series = _database.Series.FirstOrDefault(a => a.Id == id);
List <MovieGenreSeries> movieGenreSeries = _database.MovieGenreSeries.Where(a => a.SerieId == id).ToList();
_database.MovieGenreSeries.RemoveRange(movieGenreSeries);
_database.SaveChanges();
if (model.GenreString != null)
{
string[] genres = model.GenreString.Split(",");
foreach (var genre in genres)
{
MovieGenre movieGenre = _database.MovieGenres.FirstOrDefault(a => a.Name == genre);
_database.MovieGenreSeries.Add(new MovieGenreSeries {
MovieGenreId = movieGenre.Id, SerieId = series.Id
});
}
}
_database.SaveChanges();
return(RedirectToAction("View", "Series", new { Id = id }));
}
public async Task <IActionResult> AddGenre(MovieAddGenreViewModel viewModel)
{
if (!this.MovieExists(viewModel.Id))
{
return(this.NotFound());
}
if (this.ModelState.IsValid)
{
var genre = await this._dbContext.Genres.FirstOrDefaultAsync(x => x.Name == viewModel.Name);
var movieGenre = new MovieGenre()
{
MovieId = viewModel.Id,
Genre = genre
};
var movie = await this._dbContext.Movies.FindAsync(viewModel.Id);
movie.MovieGenres.Add(movieGenre);
this._dbContext.Update(movie);
await _dbContext.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(this.View(viewModel));
}
public async Task <IActionResult> Index(string SearchGenre, string searchTitle)
{
// Use LINQ to get list of genres.
IQueryable <string> gQuery = from mg in _context.Movie
orderby mg.Genre
select mg.Genre;
var movies = from m in _context.Movie
select m;
if (!String.IsNullOrEmpty(searchTitle))
{
movies = movies.Where(s => s.Title.Contains(searchTitle));
}
if (!String.IsNullOrEmpty(SearchGenre))
{
movies = movies.Where(x => x.Genre == SearchGenre);
}
var movieGVM = new MovieGenre();
movieGVM.Genres = new SelectList(await gQuery.Distinct().ToListAsync());
movieGVM.Movies = await movies.ToListAsync();
return(View(movieGVM));
}
public void TestInitialize()//Този метод се изпълнява преди извикване на всеки един от другите методи в този клас
{
testCity = new City {
Id = testCityId, Name = testCityName
};
testMovieGenre = new MovieGenre {
MovieId = testMovieId, GenreId = testGenreId
};
testMovie = new Movie
{
Id = testMovieId,
Name = testMovieName,
MovieGenres = new List <MovieGenre>()
{
testMovieGenre
},
};
testGenre = new Genre {
Id = testGenreId, Name = testGenreName
};
testProjection = new Projection
{
City = testCity,
Movie = testMovie
};
}
public ActionResult Create(Movy movie)
{
try
{
if (ModelState.IsValid)
{
VidlyDbFirstEntities1 dbsave = new VidlyDbFirstEntities1();
// had to set my values like this becos i want to set the value of my noAvailable property whenever a new movie is added
var mov = new Movy
{
Name = movie.Name,
Release_Date = movie.Release_Date,
Genre = movie.Genre,
Qty_In_Stock = movie.Qty_In_Stock,
NoAvailable = movie.Qty_In_Stock
};
var save = dbsave.Movies.Add(mov);
dbsave.SaveChanges();
return(RedirectToAction("index2", "Movies"));
}
}
catch (System.Exception ex)
{
ViewBag.Message = ex.Message;
}
ViewData["movie"] = movie;
VidlyDbFirstEntities1 db = new VidlyDbFirstEntities1();
var genre = db.Genres.ToList();
var viewmodel = new MovieGenre {
MovieGenres = genre, Movie = movie
};
return(View("Create", viewmodel));
}
public Movie(string title, string descr, int year, MovieGenre genre)
{
Title = title;
Description = Description;
Year = year;
Genre = genre;
}
//[Authorize(Roles=RoleName.CanManageMovies)]
public ActionResult Create()
{
string viewName = "Movies_Create";
VidlyDbFirstEntities1 db = new VidlyDbFirstEntities1();
var pageId = db.Pages.SingleOrDefault(c => c.Name == viewName); //use the viewname i passed to retrieve the view id
var pagerole = db.PageRoles.ToList().Where(c => c.PageID == pageId.Id); //used the viewid i retrieved to select records from db that relate to that id
foreach (var role in pagerole) //checks thru each retrieved record of roles ids
{
var dbs = new ApplicationDbContext();
var roles = dbs.Roles.SingleOrDefault(c => c.Id == role.RoleId);// i used the roleId to get the rolename from applicationdbcontext cos i need to pass the name as string
if (User.IsInRole(roles.Name))
{
if (!(ViewData["movie"] == null))
{
return(View((Movy)ViewData["movie"]));
}
var genre = db.Genres.ToList();
var viewmodel = new MovieGenre {
MovieGenres = genre
};
return(View(viewmodel));
}
//return View();
}
return(RedirectToAction("AccessDenied", "Movies"));
}
public void DeleteAllMovieGenres_WhenMovieIsDeleted()
{
// Arrange
var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>()
.UseInMemoryDatabase(databaseName: "DeleteAllMovieGenres_WhenMovieIsDeleted")
.Options;
var movieGenre = new MovieGenre();
movie.MovieGenres.Add(movieGenre);
//Act
using (var actContext = new AlphaCinemaContext(contextOptions))
{
actContext.Movies.Add(movie);
actContext.SaveChanges();
var unitOfWork = new UnitOfWork(actContext);
var command = new MovieServices(unitOfWork);
command.DeleteMovie(testMovieName);
}
//Assert
using (var assertContext = new AlphaCinemaContext(contextOptions))
{
Assert.IsTrue(movie.MovieGenres.First().IsDeleted);
}
}
// GET: Movies
public ActionResult Index(string GenreList)
{
//var movies = db.Movies.Include(m => m.Genre);
var movies = DF.MovieRepository.GetAll();
List <Genre> genres = DF.GenreRepository.GetAll().ToList();
MovieGenre mg = new MovieGenre();
mg.Genres = genres;
//var genres = DF.GenreRepository.GetAll();
ViewBag.GenreList = new SelectList(
DF.GenreRepository.GetAll().OrderBy(g => g.Name).Select(g => g.Name));
if (string.IsNullOrEmpty(GenreList))
{
mg.Movies = movies.ToList();
return View(mg);
}
else
{
mg.Movies = movies.Where(m => m.Genre.Name == GenreList).ToList();
return View(mg);
}
//return View(movies.ToList());
}
/// <summary>
/// Search movies by criteria
/// </summary>
/// <param name="criteria">Criteria used for search</param>
/// <param name="page">Page to return</param>
/// <param name="limit">The maximum number of movies to return</param>
/// <param name="ct">Cancellation token</param>
/// <param name="genre">The genre to filter</param>
/// <returns>Searched movies and the number of movies found</returns>
public async Task<Tuple<IEnumerable<MovieShort>, int>> SearchMoviesAsync(string criteria,
int page,
int limit,
CancellationToken ct,
MovieGenre genre)
{
var watch = Stopwatch.StartNew();
if (limit < 1 || limit > 50)
{
limit = 20;
}
if (page < 1)
{
page = 1;
}
var restClient = new RestClient(Constants.YtsApiEndpoint);
var request = new RestRequest("/{segment}", Method.GET);
request.AddUrlSegment("segment", "list_movies.json");
request.AddParameter("limit", limit);
request.AddParameter("page", page);
if (genre != null) request.AddParameter("genre", genre.EnglishName);
request.AddParameter("query_term", criteria);
var response = await restClient.ExecuteGetTaskAsync(request, ct);
if (response.ErrorException != null)
{
Logger.Error(
$"Error while searching movies: {response.ErrorException.Message}");
Messenger.Default.Send(new ManageExceptionMessage(new WebException(response.ErrorException.Message)));
}
var wrapper =
await Task.Run(() => JsonConvert.DeserializeObject<WrapperMovieShortDeserialized>(response.Content), ct);
if (wrapper == null)
return new Tuple<IEnumerable<MovieShort>, int>(new List<MovieShort>(), 0);
var movies = GetMoviesListFromWrapper(wrapper);
var nbMovies = wrapper.Data.MovieCount;
watch.Stop();
var elapsedMs = watch.ElapsedMilliseconds;
Logger.Debug(
$"SearchMoviesAsync ({criteria}, {page}, {limit}) in {elapsedMs} milliseconds.");
return new Tuple<IEnumerable<MovieShort>, int>(movies, nbMovies);
}
public void AddToMovieGenres(MovieGenre movieGenre)
{
base.AddObject("MovieGenres", movieGenre);
}
/// <summary>
/// Load movies for a genre
/// </summary>
/// <param name="genre"></param>
/// <returns></returns>
private async Task LoadByGenreAsync(MovieGenre genre)
{
Genre = genre.TmdbGenre.Name == LocalizationProviderHelper.GetLocalizedValue<string>("AllLabel") ? null : genre;
await LoadMoviesAsync();
}
/// <summary>
/// ChangeSelectedGenreMessage
/// </summary>
/// <param name="genre">The genre</param>
public ChangeSelectedGenreMessage(MovieGenre genre)
{
Genre = genre;
}
public static MovieGenre CreateMovieGenre(long id)
{
MovieGenre movieGenre = new MovieGenre();
movieGenre.Id = id;
return movieGenre;
}
