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));
}
