public ShowtimeEditorWindowViewModel(ShowtimeEditorWindow view, Showtime showtime,
MovieRepository movieRepository, ShowtimeRepository showtimeRepository)
{
if (showtime == null)
{
CreateMode = true;
showtime = new Showtime();
}
this.view = view;
this.movieRepository = movieRepository;
this.showtimeRepository = showtimeRepository;
Showtime = showtime;
Movies = movieRepository.GetMovies().ToList();
Auditoriums = showtimeRepository.GetAuditoriums().ToList();
if (CreateMode) return;
var movie = Movies.FirstOrDefault(_ => _.Id == showtime.Movie.Id);
view.SelectedMovieIndex = Movies.IndexOf(movie);
var auditorium = Auditoriums.FirstOrDefault(_ => _.Id == showtime.Auditorium.Id);
view.SelectedAuditoriumIndex = Auditoriums.IndexOf(auditorium);
view.Time = showtime.Time;
}
public MovieEditorWindowViewModel(IMovieEditorWindow view, Movie movie, MovieRepository repository)
{
if (movie == null)
{
createMode = true;
movie = new Movie();
}
this.view = view;
this.repository = repository;
Movie = movie;
Genres = new ObservableCollection<Genre>(repository.GetGenres());
AgeLimits = repository.GetAgeLimits().ToList();
if (createMode) return;
var limit = AgeLimits.FirstOrDefault(_ => _.Id == movie.AgeLimit.Id);
view.SelectedAgeLimitIndex = AgeLimits.IndexOf(limit);
var selectedGenres = Genres.Join(movie.Genres,
genre => genre.Id,
genre => genre.Id,
(genre1, genre2) => genre1).ToList();
selectedGenres.ForEach(_ => _.IsSelected = true);
}
public GenreListPageViewModel(GenreListPage view, MovieRepository repository)
{
this.view = view;
this.repository = repository;
RetrieveData();
}
public MovieController()
{
string cnn = ConfigurationManager.ConnectionStrings["CinemaCnn"].ToString();
var dbContext = new DatabaseContext(cnn);
var movieRepository = new MovieRepository(dbContext);
var theaterRepository = new TheaterRepository(dbContext);
var genreRepository = new GenreRepository(dbContext);
var timeIntervalRepository = new TimeIntervalRepository(dbContext);
var userRepository = new UserRepository(dbContext);
var movieUserRepository = new MovieUserRepository(dbContext);
_db = dbContext;
_movieRepository = movieRepository;
_genreRepository = genreRepository;
_theaterRepository = theaterRepository;
_timeIntervalRepository = timeIntervalRepository;
_userRepository = userRepository;
_movieUserRepository = movieUserRepository;
_movieService = new MovieService(movieRepository, theaterRepository,
_genreRepository, timeIntervalRepository);
_genreService = new GenreService(genreRepository);
_theaterService = new TheaterService(theaterRepository);
_movieUserService = new MovieUserService(movieUserRepository, movieRepository, userRepository);
}
private void BindSources(MovieRepository movieRepository)
{
if (_movieRepository != null)
_movieRepository.PropertyChanged -= MovieRepositoryPropertyChanged;
_bindingSource.DataSource = movieRepository;
_bindingSource.DataMember = "Movies";
_movieListBox.DataSource = _bindingSource;
_movieListBox.DisplayMember = "Title";
_directorComboBox.DataBindings.Clear();
_directorComboBox.DataSource = movieRepository.Directors;
_directorComboBox.DisplayMember = "FullName";
_directorComboBox.DataBindings.Add("SelectedItem", _bindingSource, "Director", true, DataSourceUpdateMode.OnPropertyChanged);
_ratingTextBox.DataBindings.Clear();
_ratingTextBox.DataBindings.Add("Text", _bindingSource, "Rating", true, DataSourceUpdateMode.OnPropertyChanged);
_descriptionTextBox.DataBindings.Clear();
_descriptionTextBox.DataBindings.Add("Text", _bindingSource, "Description", true, DataSourceUpdateMode.OnPropertyChanged);
movieRepository.PropertyChanged += MovieRepositoryPropertyChanged;
_movieRepository = movieRepository;
UpdateButtons();
}
public MovieRepository GetMovieRepository()
{
if (movieRepo == null)
{
movieRepo = new MovieRepository();
}
return movieRepo;
}
static void Main()
{
MovieRepository movieRepository = new MovieRepository();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MovieManagerDialog(movieRepository));
}
public static void ManageDirectors(MovieRepository movieRepository, IWin32Window parentWindow)
{
using (DirectorManagerDialog dlg = new DirectorManagerDialog(movieRepository))
{
dlg.StartPosition = FormStartPosition.CenterParent;
dlg.ShowDialog(parentWindow);
}
}
public RepositoryData()
{
this._movieRepository = new MovieRepository();
this._newsRepository = new NewsRepository();
this._eventRepository = new EventRepository();
this._loungeRepository= new LoungeItemRepository();
this.movielist = new List<Movie>();
}
public void T1_1()
{
var rRating = new MpaaRatingAtMostSpecification(MpaaRating.R);
var repository = new MovieRepository();
IReadOnlyList<Movie> movies = repository.Find(rRating);
movies.Count.ShouldEqual(2);
}
public void T5()
{
var gRating = new MpaaRatingAtMostSpecification(MpaaRating.G);
var goodMovie = new GoodMovieSpecification();
var repository = new MovieRepository();
IReadOnlyList<Movie> movies = repository.Find(gRating.Or(goodMovie));
movies.Count.ShouldEqual(2);
}
public GenreEditorWindowViewModel(Genre genre, MovieRepository repository)
{
if (genre == null)
{
createMode = true;
genre = new Genre();
}
this.repository = repository;
Genre = genre;
}
public BaseController()
{
string cnnString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ToString();
var dbContext = new CinemaDbContext(cnnString);
var actorsRepo = new ActorRepository(dbContext);
_actorService = new ActorService(actorsRepo);
var genreRepo = new GenreRepository(dbContext);
_genreService = new GenreService(genreRepo);
var hallRepo = new HallRepository(dbContext);
_hallService = new HallService(hallRepo);
var movieRepo = new MovieRepository(dbContext);
_movieService = new MovieService(movieRepo, actorsRepo);
}
public DirectorManagerDialog(MovieRepository movieRepository)
: this()
{
_movieRepository = movieRepository;
_bindingSource.DataSource = _movieRepository;
_bindingSource.DataMember = "Directors";
lstDirectors.DataSource = _bindingSource;
lstDirectors.DisplayMember = "FullName";
UpdateButtons();
}
public MovieEditorWindow(Movie movie)
{
InitializeComponent();
var connectionString = ConnectionStringBuilder.Build(
Settings.Default.server,
Settings.Default.database,
Settings.Default.user,
Settings.Default.password);
var repository = new MovieRepository(connectionString);
viewModel = new MovieEditorWindowViewModel(this, movie, repository);
DataContext = viewModel;
}
public MovieListPage(MainWindow window)
{
this.window = window;
InitializeComponent();
var connectionString = ConnectionStringBuilder.Build(
Settings.Default.server,
Settings.Default.database,
Settings.Default.user,
Settings.Default.password);
var repository = new MovieRepository(connectionString);
viewModel = new MovieListPageViewModel(this, repository);
DataContext = viewModel.Movies;
}
public CatalogPage()
{
InitializeComponent();
SetDefaults();
var connectionString = ConnectionStringBuilder.Build(
Settings.Default.server,
Settings.Default.database,
Settings.Default.user,
Settings.Default.password);
repository = new MovieRepository(connectionString);
viewModel = new CatalogPageViewModel(this, repository);
DataContext = viewModel;
}
/// <summary>
/// Searches the movie request.
/// </summary>
/// <param name="search">The search.</param>
/// <returns></returns>
public async Task <IEnumerable <MovieRequests> > SearchMovieRequest(string search)
{
var shouldHide = await HideFromOtherUsers();
List <MovieRequests> allRequests;
if (shouldHide.Hide)
{
allRequests = await MovieRepository.GetWithUser(shouldHide.UserId).ToListAsync();
}
else
{
allRequests = await MovieRepository.GetWithUser().ToListAsync();
}
var results = allRequests.Where(x => x.Title.Contains(search, CompareOptions.IgnoreCase)).ToList();
results.ForEach(x =>
{
x.PosterPath = PosterPathHelper.FixPosterPath(x.PosterPath);
});
return(results);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
movrepo = new MovieRepository();
List <MoviesGridData> mov = movrepo.GetMoviesForGrid();
GridView1.DataSource = mov;
GridView1.DataBind();
lanrepo = new LanguageRepository();
movrepo = new MovieRepository();
qulrepo = new QualityRepository();
genrepo = new GenreRepository();
List <LanguageTable> lan = lanrepo.GetAllLanguages();
List <GenreTable> gen = genrepo.GetAllGenres();
List <QualityTable> qual = qulrepo.GetAllQualities();
List <ReleaseYear> yr = movrepo.GetYears();
DropDownList1.DataSource = lan;
DropDownList1.DataTextField = "LanguageName";
DropDownList1.DataValueField = "LanguageID";
DropDownList1.DataBind();
DropDownList2.DataSource = qual;
DropDownList2.DataTextField = "QualityName";
DropDownList2.DataValueField = "QualityID";
DropDownList2.DataBind();
DropDownList3.DataSource = gen;
DropDownList3.DataTextField = "GenreName";
DropDownList3.DataValueField = "GenreID";
DropDownList3.DataBind();
DropDownList4.DataSource = yr;
DropDownList4.DataBind();
}
}
public Movie GetMovie(int id)
{
var repo = new MovieRepository();
var movie = repo.GetMovie(id);
if (movie != null)
{
return new Movie {
Id = movie.id, Title = movie.title, Rating = movie.rating
}
}
;
DataBaseFault fault = new DataBaseFault
{
OperationName = "Get movie by Id",
ExceptionMessage = "No Movie found by the requested Id"
};
throw new FaultException <DataBaseFault>(fault);
}
public async void GetRatingsAsync_ForAnEmptyListOfMovies_ReturnsAnEmptyList()
{
// Given
var movies = new List <Movie>();
using (var context = new MovieDbContext(_options))
{
BuildMoviesContext(context);
await context.SaveChangesAsync();
}
using (var context = new MovieDbContext(_options))
using (var movieRepo = new MovieRepository(context))
{
// When
var ratings = await movieRepo.GetRatingsAsync(movies);
// Then
Assert.NotNull(ratings);
Assert.Empty(ratings);
}
}
/// <summary>
/// Gets the requests.
/// </summary>
/// <returns></returns>
public async Task <IEnumerable <MovieRequests> > GetRequests()
{
var shouldHide = await HideFromOtherUsers();
List <MovieRequests> allRequests;
if (shouldHide.Hide)
{
allRequests = await MovieRepository.GetWithUser(shouldHide.UserId).ToListAsync();
}
else
{
allRequests = await MovieRepository.GetWithUser().ToListAsync();
}
allRequests.ForEach(async x =>
{
x.PosterPath = PosterPathHelper.FixPosterPath(x.PosterPath);
await CheckForSubscription(shouldHide, x);
});
return(allRequests);
}
// GET: Movie/Edit/5
public ActionResult Edit(int id)
{
var repository = new MovieRepository(context);
var personaRepository = new PersonaRepository(context);
var generoRepository = new GeneroRepository(context);
// Expresión lambda para incluir las relaciones (No hay carga perezosa)
var includes = new Expression <Func <Movie, object> >[] { s => s.Actores, s => s.Generos };
var movie = repository.QueryIncluding(x => x.MediaId == id, includes).SingleOrDefault();
var model = MapHelper.Map <MovieViewModel>(movie);
var actores = personaRepository.Query(a => a.Status == true);
var generos = generoRepository.Query(g => g.Activo == true);
model.ActoresDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(actores);
model.ActoresSeleccionados = movie.Actores.Select(a => a.Id.Value).ToArray();
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(generos);
model.GenerosSeleccionados = movie.Generos.Select(g => g.GeneroId.Value).ToArray();
return(View(model));
}
public async Task <RequestEngineResult> MarkAvailable(int modelId)
{
var request = await MovieRepository.Find(modelId);
if (request == null)
{
return(new RequestEngineResult
{
ErrorMessage = "Request does not exist"
});
}
request.Available = true;
NotificationHelper.Notify(request, NotificationType.RequestAvailable);
await MovieRepository.Update(request);
return(new RequestEngineResult
{
Message = "Request is now available",
Result = true
});
}
public async void GetAllMovieRatingsForUserAsync_ValidUser_ReturnsAllRatings()
{
// Given
using (var context = new MovieDbContext(_options))
{
BuildMoviesContext(context);
await context.SaveChangesAsync();
}
using (var context = new MovieDbContext(_options))
using (var movieRepo = new MovieRepository(context))
{
// When
var result = await movieRepo.GetAllMovieRatingsForUserAsync(1);
// Then
Assert.NotNull(result);
Assert.NotEmpty(result);
var ratingsList = new List <UserRating>(result);
Assert.Equal(9, ratingsList.Count);
}
}
public IActionResult Details(Guid id)
{
var repository = new MovieRepository(HttpContext.Session);
var movie = repository.Get(id);
if (movie == null)
{
return(RedirectToAction(nameof(Index)));
}
var viewModel = new MovieDetailsViewModel
{
Title = movie.Title,
Description = movie.Description,
ReleaseDate = movie.ReleaseDate,
RunTime = movie.RunTime,
Color = movie.Color,
Score = movie.Score
};
return(View(viewModel));
}
public async Task <RequestEngineResult> DenyMovieById(int modelId)
{
var request = await MovieRepository.Find(modelId);
if (request == null)
{
return(new RequestEngineResult
{
ErrorMessage = "Request does not exist"
});
}
request.Denied = true;
// We are denying a request
NotificationHelper.Notify(request, NotificationType.RequestDeclined);
await MovieRepository.Update(request);
return(new RequestEngineResult
{
Message = "Request successfully deleted",
});
}
public void Log_When_Movie_Is_Deleted_And_Send_An_Email()
{
var contextMock = new Mock <MovieContext>();
var logMock = new Mock <ILog>();
var mailerMock = new Mock <IMailer>();
var repository = new MovieRepository(contextMock.Object, logMock.Object, mailerMock.Object);
var movieToDelete = new Movie()
{
Id = 1, Name = "Star Wars"
};
logMock.Setup(x => x.InfoFormat("Movie with id {0} and name {1} was deleted!", 1, "Star Wars"));
contextMock.Setup(x => x.Movies.Find(1)).Returns(movieToDelete);
contextMock.Setup(x => x.Movies.Remove(movieToDelete));
contextMock.Setup(x => x.SaveChanges());
mailerMock.Setup(x => x.SendEmail("*****@*****.**", "*****@*****.**", "Movie with name Star Wars was deleted!"));
repository.DeleteMovie(1);
logMock.VerifyAll();
contextMock.VerifyAll();
}
public List <Movie> GetMovies()
{
var repo = new MovieRepository();
var movies = repo.GetMovies()
.Select(movie => new Movie {
Id = movie.id, Title = movie.title, Rating = movie.rating
})
.ToList();
if (movies.Count != 0)
{
return(movies);
}
DataBaseFault fault = new DataBaseFault
{
OperationName = "Get all Movies",
ExceptionMessage = "No Movies found"
};
throw new FaultException <DataBaseFault>(fault);
}
/// <summary>
/// Updates the movie request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
public async Task <MovieRequests> UpdateMovieRequest(MovieRequests request)
{
var allRequests = await MovieRepository.GetWithUser().ToListAsync();
var results = allRequests.FirstOrDefault(x => x.Id == request.Id);
results.Approved = request.Approved;
results.Available = request.Available;
results.Denied = request.Denied;
results.DeniedReason = request.DeniedReason;
results.ImdbId = request.ImdbId;
results.IssueId = request.IssueId;
results.Issues = request.Issues;
results.Overview = request.Overview;
results.PosterPath = PosterPathHelper.FixPosterPath(request.PosterPath);
results.QualityOverride = request.QualityOverride;
results.RootPathOverride = request.RootPathOverride;
await MovieRepository.Update(results);
return(results);
}
public ActionResult Edit(Movie movie)
{
if (ModelState.IsValid)
{
MovieRepository movieRepository = new MovieRepository(db);
movie.DateAdded = DateTime.Now;
movieRepository.SetState(movie, EntityState.Modified);
movieRepository.Update(movie);
movieRepository.Commit();
return(RedirectToAction("Index"));
}
// Got here, so show the edit form again.
AddUpdateMovieModel addUpdateMovieModel = new AddUpdateMovieModel(movie); // Create the model from details
// supplied into the controller
GenreRepository genreRepository = new GenreRepository(db);
var genres = genreRepository.GetAll().ToList();
addUpdateMovieModel.genres = genres;
addUpdateMovieModel.PageTitle = "Edit Movie";
return(View(addUpdateMovieModel));
}
//
// GET: /Movies/
public ActionResult Index()
{
var repository = new MovieRepository();
if (repository.IsEmpty)
{
PopulateDefaultMovies(repository);
}
var movies = repository.All();
var result =
JsonConvert.SerializeObject(
new { movies },
Formatting.Indented,
new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver()
}
);
return(this.Content(result, "application/json"));
}
public async void GetMoviesByIdsAsync_EmptyList_ReturnsEmptyList()
{
// Given
var movieIds = new List <int>();
using (var context = new MovieDbContext(_options))
{
BuildMoviesContext(context);
await context.SaveChangesAsync();
}
using (var context = new MovieDbContext(_options))
using (var movieRepo = new MovieRepository(context))
{
// When
var result = await movieRepo.GetMoviesByIdsAsync(movieIds);
// Then
Assert.NotNull(result);
Assert.Empty(result);
}
}
public ActionResult Index(string genre, string search)
{
MovieRepository rep = new MovieRepository();
IEnumerable <Genre> genres = rep.GetAllGenres();
IEnumerable <Movie> movies;
if (!string.IsNullOrEmpty(search))
{
movies = rep.FindMoviesByTitle(search);
}
else if (!string.IsNullOrEmpty(genre))
{
Genre selectedGenre = genres.SingleOrDefault(g => g.Description == genre);
if (null == selectedGenre)
{
movies = rep.GetAllMovies();
}
else
{
movies = selectedGenre.Movies;
}
}
else
{
movies = rep.GetAllMovies();
}
ViewBag.Genres = genres;
if (Request.IsAjaxRequest())
{
return(PartialView(movies));
}
else
{
return(View(movies));
}
}
public void DisplayMenu()
{
string selectFromMenu;
var movieRepository = new MovieRepository();
do
{
userMenu();
selectFromMenu = System.Console.ReadLine();
switch (selectFromMenu)
{
case "1":
_movieContexts.GetAll();
break;
case "2":
_movieContexts.ReadDB();
break;
case "3":
_movieContexts.Add();
break;
case "4":
_movieContexts.Update();
break;
case "5":
_movieContexts.Delete();
break;
case "6":
_movieContexts.addUser();
break;
}
}while (selectFromMenu != "7");
}
public static async Task TasksOnStartUp(IConfiguration configuration, IMemoryCache memoryCache)
{
var categoryMapping = new CategoryMapping(new CategoryRepository(configuration, memoryCache),
new CategoryRelRepository(configuration, memoryCache));
await categoryMapping.PopulateAllCategories();
var movieRepo = new MovieRepository(configuration, memoryCache);
var movies = await movieRepo.GetAllMovies();
if (!configuration.GetConnectionString("DefaultConnection").Contains("test"))
{
await MovieGenrePopulating.PopulateTmdbMovieGenres(new MovieGenreRepository(configuration,
memoryCache));
await TVShowGenrePopulating.PopulateTmdbTVShowGenres(new TVShowGenreRepository(configuration, memoryCache));
await new MoviePopulating(configuration, memoryCache).PopulateManyMovies();
await new TVShowPopulating(configuration, memoryCache).PopulateManyTVShowsTask();
// await new MediaListPopulating(configuration, memoryCache).CreateImdbMovieList("ls051203792",
// "\"The Great Movies\" by Roger Ebert");
// await new MediaListPopulating(configuration, memoryCache).CreateImdbMovieList("ls055315312",
// "Top 95 Spy/Thriller Movies");
//
// await new MediaListPopulating(configuration, memoryCache).CreateImdbTVShowList("ls004499891",
// "Best Of The Best TV Shows of 2000-2017");
//
// await new MediaListPopulating(configuration, memoryCache).CreateImdbTVShowList("ls059270048",
// "TV Series I Would Watch Again (2000-2014)");
//
// await new MediaListPopulating(configuration, memoryCache).CreateImdbTVShowList("ls051600015",
// "250: Top TV Series, HBO, Showtime:");
}
}
public ActionResult Create(Movie movie)
{
if (movie.MovieId == 0)
{
MovieRepository movieRepository = new MovieRepository(db);
movie.DateAdded = DateTime.Now;
movieRepository.Insert(movie); // Add the movie to the repository
movieRepository.Commit(); // SaveChanges to the repository
return(RedirectToAction("Index"));
}
// Got here, so show the Create form again with details input so far
GenreRepository genreRepository = new GenreRepository(db);
var genres = genreRepository.GetAll().ToList();
AddUpdateMovieModel addUpdateMovieModel = new AddUpdateMovieModel(movie); // Create the model from details supplied into the controller
addUpdateMovieModel.genres = genres;
addUpdateMovieModel.PageTitle = "Create Movie";
return(View(addUpdateMovieModel));
}
public void Test_Add_ListAll()
{
Movie mov = new Movie() { Id = 20, Title = "Avengers: Age Of Ultron", Genre = new Genre() { Id = 2, Name = "Action" }, Price = 150, Year = DateTime.Now.Date, ImgUrl = "http://scaled.ysimag.es/movie/the-avengers-age-of-ultron", TrailerUrl = "https://www.youtube.com/watch?v=S2HIda5wSVU" };
mov.Id = 1;
mov.Title = "Alice in Wonderland";
mov.Genre.Id = 2;
mov.Genre.Name = "Action";
mov.Price = 150;
mov.ImgUrl = "http://scaled.ysimag.es/movie/the-avengers-age-of-ultron";
mov.TrailerUrl = "https://www.youtube.com/watch?v=S2HIda5wSVU";
mov.Year = DateTime.Now.Date;
MovieRepository repository = new MovieRepository();
int numberOfMovies = repository.GetAll().Count();
Movie result = repository.Add(mov);
Assert.NotNull(result);
int finalNumberOfMovies = repository.GetAll().Count();
Assert.AreEqual(numberOfMovies + 1, finalNumberOfMovies);
}
public ActionResult Edit(int id, MovieViewModel model)
{
//var topicRepository = new TopicRepository(context);
try
{
var repository = new MovieRepository(context);
if (ModelState.IsValid)
{
var movie = MapHelper.Map <Movie>(model);
repository.Update(movie);
context.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
catch (Exception ex)
{
return(View(model));
}
}
public void SaveChangesWithNoChangesDoesntThrowException()
{
// arrange
var options = new DbContextOptionsBuilder <MoviesDBContext>()
.UseInMemoryDatabase("no_changes_test").Options;
using (var db = new MoviesDBContext(options))
{
// do nothing
// (just creating the DbContext class with in-memory options
// automatically creates the in-memory DB too.)
}
// act
using (var db = new MoviesDBContext(options))
{
var repo = new MovieRepository(db);
repo.SaveChanges(); // assert
}
// assert
// (no exception should have been thrown)
}
public void Test_Update()
{
MovieRepository repository = new MovieRepository();
GenreRepository gr = new GenreRepository();
Movie mov = repository.Get(1);
Assert.NotNull(mov);
mov.Title = "Red";
mov.Genre = gr.Get(3);
mov.Price = 20;
mov.ImgUrl = "http://scaled.ysimag.es/movie/it-follows";
mov.TrailerUrl = "https://www.youtube.com/watch?v=w0qQkSuWOS8";
mov.Year = DateTime.Today.Date;
Movie result = repository.Update(mov);
Assert.AreEqual(result.Title,"Red");
Assert.AreEqual(result.Genre.Id, 3);
Assert.AreEqual(result.Price, 20);
Assert.AreEqual(result.ImgUrl, "http://scaled.ysimag.es/movie/it-follows");
Assert.AreEqual(result.TrailerUrl, "https://www.youtube.com/watch?v=w0qQkSuWOS8");
Assert.AreEqual(result.Year, DateTime.Today.Date);
}
public async Task <RequestEngineResult> MarkUnavailable(int modelId)
{
var request = await MovieRepository.Find(modelId);
if (request == null)
{
return(new RequestEngineResult
{
ErrorMessage = "Request does not exist"
});
}
request.Available = false;
await MovieRepository.Update(request);
await _mediaCacheService.Purge();
return(new RequestEngineResult
{
Message = "Request is now unavailable",
Result = true
});
}
public async Task GetListableItems(MediaList mediaList)
{
var relationRepository = new RelationRepository(Configuration, MemoryCache);
var relList = await relationRepository.GetRelationsByParent(
mediaList.GetEntityCategoryId(), mediaList.GetId());
//TODO FIX!!!!
var movieRepository = new MovieRepository(Configuration, MemoryCache);
var tvShowRepository = new TVShowRepository(Configuration, MemoryCache);
foreach (var relation in relList)
{
if (relation.CategoryTo == Movie.ENTITY_CATEGORY_ID)
{
mediaList.AddListableItem(await movieRepository.GetById(relation.EntityTo));
}
else if (relation.CategoryTo == TVShow.ENTITY_CATEGORY_ID)
{
mediaList.AddListableItem(await tvShowRepository.GetById(relation.EntityTo));
}
}
}
public async Task <RequestEngineResult> UpdateAdvancedOptions(MediaAdvancedOptions options)
{
var request = await MovieRepository.Find(options.RequestId);
if (request == null)
{
return(new RequestEngineResult
{
Result = false,
ErrorMessage = "Request does not exist"
});
}
request.QualityOverride = options.QualityOverride;
request.RootPathOverride = options.RootPathOverride;
await MovieRepository.Update(request);
return(new RequestEngineResult
{
Result = true
});
}
/// <summary>
/// Lets the user delete a book with the specific id
/// </summary>
private void DeleteMovie()
{
Console.Clear();
List <Movie> movies = MovieRepository.GetMovies();
Console.WriteLine("Id Title - Language - Year Of Publication - Genre - Type - Copies");
for (int i = 0; i < movies.Count; i++)
{
Console.WriteLine($"{i + 1}: Movie: {movies[i].Title} {movies[i].Language} {movies[i].YearOfPublication} {movies[i].Genre} {movies[i].Type} {movies[i].Copies}");
}
Console.WriteLine("Choose movie id to delete: ");
string input = Console.ReadLine();
int selectedNumber = int.Parse(input);
Movie deleteMovie = movies[selectedNumber - 1];
MovieRepository.DeleteMovieById(deleteMovie.Id);
}
private async Task <RequestEngineResult> AddMovieRequest(MovieRequests model, string movieName)
{
await MovieRepository.Add(model);
var result = await RunSpecificRule(model, SpecificRules.CanSendNotification);
if (result.Success)
{
NotificationHelper.NewRequest(model);
}
await _requestLog.Add(new RequestLog
{
UserId = (await GetUser()).Id,
RequestDate = DateTime.UtcNow,
RequestId = model.Id,
RequestType = RequestType.Movie,
});
return(new RequestEngineResult {
Result = true, Message = $"{movieName} has been successfully added!", RequestId = model.Id
});
}
public ViewResult Videos(int id = 1)
{
ViewBag.Current = "Videos";
ViewBag.CurrentPage = id;
MovieRepository rm = new MovieRepository();
//Mapping
List <Movie> ModelDb = rm.Paginate(id, 9);
ViewBag.MaxPages = Math.Round((double)rm.getNbMovies() / 9);
//tranférer les données du modeldb vers MovieReview
List <MovieInfo> lm = new List <MovieInfo>();
foreach (Movie item in ModelDb)
{
lm.Add(new MovieInfo()
{
Title = item.Title,
Picture = item.Picture,
Video = item.Trailer.Replace("watch?v=", "embed/")
});
}
return(View(lm));
}
public ActionResult Save(string save)
{
List <string> messages = new List <string>();
if (save == "Yes")
{
BulkLoadOutput blo = (BulkLoadOutput)TempData["blo"];
if (blo != null)
{
MovieRepository rep = new MovieRepository();
foreach (Movie m in blo.ResolvedMovie)
{
try
{
rep.Add(m);
rep.Save();
messages.Add("Successfully add movie " + m.Title);
}
catch
{
messages.Add("Unable to add movie " + m.Title
+ ". Perhaps it is already in the database.");
}
}
}
else
{
messages.Add("No movies loaded.");
}
}
else
{
messages.Add("Bulk Load operation is successfully cancelled.");
}
return(View(messages));
}
public ActionResult Index(string sortOrder)
{
MovieRepository movieRepository = new MovieRepository();
ViewBag.Category = ListofCategories();
IEnumerable<Movie> movies = null;
using (movieRepository)
{
movies = movieRepository.SelectAll() as IList<Movie>;
}
switch (sortOrder)
{
case "Title":
movies = movies.OrderBy(b => b.Title);
break;
case "Year":
movies = movies.OrderBy(b => b.Year);
break;
case "Category":
movies = movies.OrderBy(b => b.Category);
break;
case "Leading Actor":
movies = movies.OrderBy(b => b.LeadingActor);
break;
case "Director":
movies = movies.OrderBy(b => b.Director);
break;
default:
movies = movies.OrderBy(b => b.Title);
break;
}
return View(movies);
}
public RentalFactory(MovieRepository movieRepository)
{
this.movieRepository = movieRepository;
}
public DataService(MovieRepository movieRepository)
{
MovieRepository = movieRepository;
}
public MovieRepositoryTest()
{
_movieRepository = new MovieRepository();
movielist = new List<Movie>();
}
public MovieController()
{
movieRepo = new MovieRepository();
}
public DALFacade()
{
_customersRepository = new CustomerRepository();
_moviesRepository = new MovieRepository();
_orderRepository = new OrderRepository();
}
public List<Movie> ListMovies(double waveId)
{
FeatureRepository<Movie> repository = new MovieRepository();
return repository.ListFeatures(waveId);
}
public MovieController(MovieRepository repo)
{
searchHelper = new SearchHelper(repo);
}
public MovieManagerDialog(MovieRepository movieRepository)
: this()
{
BindSources(movieRepository);
}
