public async Task <ActionResult <MoviesModel> > PostMovies([FromBody] MoviesModel Movies) { _context.Movies.Add(Movies); await _context.SaveChangesAsync(); return(CreatedAtAction("GetMovies", new { id = Movies.ID }, Movies)); }
public List <MoviesModel> hhi() { MoviesModel enp = new MoviesModel(); List <MoviesModel> listemp = new List <MoviesModel>(); SqlConnection con1 = null; try { con1 = new SqlConnection("data source=.;database=MovieReviewDb;integrated security=SSPI"); con1.Open(); SqlCommand cmd = new SqlCommand("select * from Movies", con1); SqlDataReader sdrd = cmd.ExecuteReader(); while (sdrd.Read()) { enp = new MoviesModel(); //enp.MovieId = (int)sdrd["MovieId"]; enp.MovieName = (string)sdrd["MovieName"]; enp.DirectorName = (string)sdrd["DirectorName"]; enp.MoviewImageId = (int)sdrd["MoviewImageId"]; enp.ReleasedDate = (DateTime)sdrd["ReleasedDate"]; enp.Feedback = (string)sdrd["Feedback"]; enp.Images = (string)sdrd["Images"]; //enp.LastName = (string)sdrd["LastName"]; //enp.Email = (string)sdrd["Email"]; listemp.Add(enp); } } catch (Exception Ex) { Console.WriteLine("ERROR", Ex); } return(listemp); }
public ActionResult GetSortedMoviesByPrice(string dataProvider) { DataManager Manager = new DataManager(); MoviesModel MoviesData = Manager.GetSortedMoviesByPrice(dataProvider); return(Json(MoviesData, JsonRequestBehavior.AllowGet)); }
public IActionResult Index(int page = 0) //each movie at index calls the details method { const int PageSize = 20; var movies = from m in db.Movies select m; int count = movies.Count(); var data = movies.OrderBy(o => o.MovieID).Skip(page * PageSize).Take(PageSize).ToList(); //get 20 results per page ViewBag.MaxPage = (count / PageSize) - (count % PageSize == 0 ? 1 : 0); ViewBag.Page = page; List <string> s = new List <string>(); foreach (var m in data) { s.Add((getImage(m.Title).Result)); } ; var model = new MoviesModel { statement = "This is my random statement", //Movie = db.Movies.ToList(),//??????????????????????????? :((((( Movie = data.ToList(), Links = s }; return(View(model)); }
/// <summary> /// Metodo para processar cada fase do campeonato e retornar vencedores do campeonato 1º e 2º colocados /// </summary> /// <param name="competidores">lista de competidores selecionados</param> /// <returns>Retorna competidores vencedores (1º e 2º) colocados</returns> public static IEnumerable <MoviesModel> ProcessarCampeonato(List <MoviesModel> competidores) { IList <MoviesModel> champions = new List <MoviesModel>(); MoviesModel campeaoDaPartida = null; bool ultimaPartida = false; int nroPartida = 1; if (!competidores.Any()) { PrintLog("Não foram selecionados competidores!"); return(champions); } foreach (var item in competidores) { PrintLog(item.Id + " - " + item.Titulo + " - " + item.Ano + " - " + item.Nota, false); } PrintLog(""); foreach (var item in competidores.ToList()) { PrintLog("Partida: " + nroPartida++); var competidor1 = competidores.First(); var competidor2 = competidores.Last(); PrintLog(competidor1.Titulo + " - Nota:" + competidor1.Nota + " === X === " + competidor2.Titulo + " - Nota:" + competidor2.Nota, false); campeaoDaPartida = IniciarPartida(competidor1, competidor2); PrintLog("Vencedor: " + campeaoDaPartida.Titulo + " - Nota:" + campeaoDaPartida.Nota); champions.Add(campeaoDaPartida); //Removendo competidores da partida anterior a não ser que for a ultima partida if (!ultimaPartida) { competidores.Remove(competidor1); competidores.Remove(competidor2); } else { campeaoDaPartida.Campeao = true; break; } if (!competidores.Any()) { competidores.AddRange(champions); champions.Clear(); if (competidores.Count == 2) { ultimaPartida = true; } } } return(competidores); }
public ActionResult FilterCategory(int id) { MoviesModel ListOfMovies = new MoviesModel(); ListOfMovies = Movies; ListOfMovies.FilterCatergory = id; if (ListOfMovies.FilterCatergory == 1) { ListOfMovies.Movies = ListOfMovies.Movies.OrderByDescending(o => o.Popularity).ToList(); } else if (ListOfMovies.FilterCatergory == 2) { ListOfMovies.Movies = ListOfMovies.Movies.OrderBy(o => o.Title).ToList(); } else if (ListOfMovies.FilterCatergory == 3) { ListOfMovies.Movies = ListOfMovies.Movies.OrderByDescending(o => o.Release_date).ToList(); } Movies = ListOfMovies; if (Session["username"] != null) { Movies.Watchlist = GetMovieWatchlist(); } return(View(Movies)); }
public ActionResult Search(int id) { MoviesModel SearchMovies = new MoviesModel(); if (Movies.Pages > Movies.Current_Page && id > 1) { SearchMovies = API_Movie.SearchMovie(Movies.Search, id); } else { SearchMovies = API_Movie.SearchMovie(Movies.Search); } Movies.Movies = SearchMovies.Movies; Movies.Pages = SearchMovies.Pages; Movies.Current_Page = SearchMovies.Current_Page; if (Session["username"] != null) { Movies.Watchlist = GetMovieWatchlist(); } return(View(Movies)); }
public ActionResult Search(MoviesModel model) { MoviesModel SearchMovies = new MoviesModel(); if (model.Search == null) { return(View(Movies)); } model.Search = model.Search.Replace(" ", "%20"); if (model.Pages > model.Current_Page && model.Current_Page > 1) { SearchMovies = API_Movie.SearchMovie(model.Search, model.Current_Page); } else { SearchMovies = API_Movie.SearchMovie(model.Search); } Movies = SearchMovies; Movies.Search = model.Search; if (Session["username"] != null) { Movies.Watchlist = GetMovieWatchlist(); } return(View(Movies)); }
public async Task <IActionResult> Edit(int id, [Bind("MovieID,Category,Title,Year,Director,Rating,Edited,Lent,Notes")] MoviesModel moviesModel) { if (id != moviesModel.MovieID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(moviesModel); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!MoviesModelExists(moviesModel.MovieID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(moviesModel)); }
public async Task <IActionResult> Edit(int id, [Bind("MovieID,MovieName,MovieDescription,GenreName")] MoviesModel moviesModel) { if (id != moviesModel.MovieID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(moviesModel); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!MoviesViewModelExists(moviesModel.MovieID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["GenreName"] = new SelectList(_context.Genres, "GenreName", "Genre Name", moviesModel.GenresModel.GenreName); return(View(moviesModel)); }
public async Task <IActionResult> PutMovies(int id, MoviesModel Movies) { if (id != Movies.ID) { return(BadRequest()); } _context.Entry(Movies).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!MoviesExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task GetAsync_MutualVotesIsNotEnoughExceptionThrown_IsVotesNotEnoughTrue() { var pageContext = CreatePageContext(true); var fakeUserStore = new Mock <IUserStore <AppUser> >(); var fakeUserManager = new Mock <UserManager <AppUser> >(fakeUserStore.Object, null, null, null, null, null, null, null, null); fakeUserManager.Setup(m => m.FindByNameAsync(It.IsAny <string>())) .ReturnsAsync(new AppUser { Id = "id" }); var fakeUserService = new Mock <IUserService>(); var fakeVoteService = new Mock <IVoteService>(); fakeVoteService .Setup(s => s.GetVotesSimilarityAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>())) .ThrowsAsync(new NotEnoughVotesException(It.IsAny <int>())); var fakeLogger = new Mock <ILogger <MoviesModel> >(); var moviesModel = new MoviesModel(fakeUserService.Object, fakeVoteService.Object, fakeUserManager.Object, fakeLogger.Object, Mapper) { RequestInitiator = RequestInitiator.Guest, PageContext = pageContext }; await moviesModel.OnGetAsync(); Assert.True(moviesModel.IsVotesNotEnough); }
public IActionResult AllMovies() { MoviesModel model = new MoviesModel(); model.Movies = movies.GetAllMovies(); return(View(model)); }
public IActionResult MoviesThisWeek() { MoviesModel model = new MoviesModel(); model.Movies = movies.GetMoviesPlayingThisWeek(); return(View(model)); }
public StatusCodeResult AddNewMovie([FromBody] MoviesModel movie) { if (_moviesRepository.AddNewMovie(movie)) { return(new StatusCodeResult(200)); } return(new StatusCodeResult(400)); }
public static MoviesModel GetUpComingMovies(int page = 1) { string movies_str = UpComingMovies(page).Result; MoviesModel Movies = StringToModel(movies_str); Movies.Current_Page = page; return(Movies); }
public IActionResult Bookings(int?movieId) { BookingsModel model = new BookingsModel(); MoviesModel moviesM = new MoviesModel(); model.Movies = manager.GetUserBookings(movieId.Value); return(RedirectToAction(nameof(Bookings))); }
public IActionResult Manage() { var model = new MoviesModel("Manage Movies") { Movies = _movieRepository.GetMovies() }; return(View(model)); }
public ActionResult <AllMoviesViewModel> GetViewModel(MoviesModel moviesModel, ActorLookupModel actorLookupModel, DirectorLookupModel directorLookupModel) { return(new AllMoviesViewModel { Movies = moviesModel.Movies, Total = moviesModel.Movies.Count, ActorLookups = actorLookupModel.ActorLookups, DirectorLookups = directorLookupModel.DirectorLookups }); }
/// <summary> /// Metodo de desempate para retornar competidor ganhador, baseado na ordem alfabetica dos nomes /// </summary> /// <param name="competidor1">Competidor numero 1</param> /// <param name="competidor2">Competidor numero 1</param> /// <returns>Retorna competidor vencedor</returns> public static MoviesModel Desempate(MoviesModel competidor1, MoviesModel competidor2) { List <MoviesModel> competidores = new List <MoviesModel> { competidor1, competidor2 }; return(competidores.OrderBy(o => o.Titulo).First()); }
public ActionResult Movies() { MoviesModel moviesModel = new MoviesModel() { Movies = _context.Movies.Include(c => c.Genre).ToList().OrderBy(x => x.Name) }; return(View(moviesModel)); }
// GET: MyLibrary public ActionResult Index() { Users loggedUser = (Users)Session["loggedUser"]; MoviesModel context = new MoviesModel(); IndexVM model = new IndexVM(); model.Items = context.MyLibrary.Where(i => i.UserId == loggedUser.UseId).ToList(); return(View(model)); }
public async Task <IActionResult> Create([Bind("MovieID,Category,Title,Year,Director,Rating,Edited,Lent,Notes")] MoviesModel moviesModel) { if (ModelState.IsValid) { _context.Add(moviesModel); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(moviesModel)); }
public async Task <IActionResult> Create([Bind("ID,Title,Genre,Runtime")] MoviesModel moviesModel) { if (ModelState.IsValid) { _context.Add(moviesModel); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(MovieList))); } return(View(moviesModel)); }
public ThumbnailViewModel(MoviesModel movieModel) { this.Id = movieModel.Id; this.Title = movieModel.Title; this.ImageUrl = movieModel.ImageUrl; this.Description = movieModel.Plot; this.ReleaseDate = movieModel.ReleaseDate; this.Runtime = movieModel.Runtime; this.Vote = movieModel.Vote; this.Type = ThumbnailType.Movie; }
public async Task <IActionResult> Create(MoviesModel movie) { var userId = User.FindFirstValue(ClaimTypes.NameIdentifier); movie.UserUid = userId; db.MoviesEF.Add(movie); await db.SaveChangesAsync(); return(RedirectToAction("Index")); }
public IActionResult Index(int?page) { var movies = serviceMovies.Populate(); MoviesModel moviesModel = Mapper.Map <MoviesModel>(movies); if (page > 1) { return(View(moviesModel.results.ToPagedList(page.Value, 5))); } return(View(moviesModel.results.ToPagedList(1, 5))); }
public static MoviesModel GetCurrentlyPlayingMovies(int page = 1) { string movies_str = Currently_Playing(page).Result; if (movies_str != "NULL") { MoviesModel Movies = StringToModel(movies_str); Movies.Current_Page = page; return(Movies); } return(new MoviesModel()); }
public IActionResult Purchase(IFormCollection Collection) { string str = HttpContext.Session.GetString("MoviesModel"); MoviesModel mm = JsonConvert.DeserializeObject <MoviesModel>(str); mm.Name = Collection["Name"]; mm.Movie = Collection["MoviesList"]; // Idk if this will work... mm.Tickets = int.Parse(Collection["Tickets"]); mm.Popcorn = Convert.ToBoolean(Collection["Popcorn"].ToString().Split(',')[0]); return(View(mm)); }
public ActionResult AddToMovieWatchlist(string id, string title, string watchlistname, string release_date) { MovieWatchlist MovieWatchlist = new MovieWatchlist(); var db = new MovieTimeEntities6(); string UserID = (string)Session["username"].ToString(); var listofMovies = db.MovieWatchlists.Where(x => x.WatchlistName.Equals(watchlistname)).ToList(); if (listofMovies.Count == 0) { return(RedirectToAction("Index", "Movie")); } Random rnd = new Random(); MovieWatchlist.ID = rnd.Next(1, 10000000).ToString(); List <MovieWatchlist> check = db.MovieWatchlists.Where(m => m.ID.Equals(MovieWatchlist.ID) && m.UserID.Equals(UserID)).ToList(); while (check.Count != 0) { MovieWatchlist.ID = rnd.Next(1, 10000000).ToString(); check = db.MovieWatchlists.Where(m => m.ID.Equals(MovieWatchlist.ID) && m.UserID.Equals(UserID)).ToList(); } foreach (var movie in Movies.Movies) { if (movie.Title.Equals(title) && movie.Release_date.Equals(release_date)) { MovieWatchlist.UserID = UserID; MovieWatchlist.WatchlistName = watchlistname; MovieWatchlist.Overview = movie.Overview; MovieWatchlist.Popularity = movie.Popularity.ToString(); MovieWatchlist.Release_date = movie.Release_date; MovieWatchlist.Poster_path = movie.Poster_path; MovieWatchlist.Title = movie.Title; MovieWatchlist.MovieID = movie.Id; break; } } db.Entry(MovieWatchlist).State = System.Data.Entity.EntityState.Added; db.SaveChanges(); Movies.Search = null; MoviesModel temp = new MoviesModel(); temp = Movies; temp.Watchlist = GetMovieWatchlist(); return(View(temp)); }