public async Task <ActionResult <Screening> > AddScreening([FromForm] Screening screening)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var movie = context.Movies.FirstOrDefault(m => m.MovieId == screening.MovieId);
if (movie == null)
{
return(NotFound());
}
screening.Movie = movie;
var screeningRoom = context.ScreeningRooms.FirstOrDefault(sr => sr.ScreeningRoomId == screening.ScreeningRoomId);
if (screeningRoom == null)
{
return(NotFound());
}
screening.ScreeningRoom = screeningRoom;
context.Add(screening);
await context.SaveChangesAsync();
return(new OkObjectResult(screening));
}
public async Task <IActionResult> PutShowing(int id, Showing showing)
{
if (id != showing.ShowingID)
{
return(BadRequest());
}
_context.Entry(showing).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ShowingExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutActor(int id, Actor actor)
{
if (id != actor.Id)
{
return(BadRequest());
}
_context.Entry(actor).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ActorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutMovie(int id, Movie movie)
{
if (id != movie.MovieID)
{
return(BadRequest());
}
_context.Entry(movie).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult> Create([Bind(Include = "ID,Title,ReleaseDate,GenreId,Rating,Description,YouTubeLink")] Movie movie, HttpPostedFileBase upload)
{
if (upload != null && upload.ContentLength > 0)
{
var Picture = new Models.File
{
FileName = System.IO.Path.GetFileName(upload.FileName),
FileType = FileType.Stock,
ContentType = upload.ContentType
};
using (var reader = new System.IO.BinaryReader(upload.InputStream))
{
Picture.Content = reader.ReadBytes(upload.ContentLength);
}
movie.Files = new List <Models.File> {
Picture
};
}
if (ModelState.IsValid)
{
db.Movies.Add(movie);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.GenreId = new SelectList(db.Genres, "ID", "Name", movie.GenreId);
return(View(movie));
}
public async Task <IActionResult> Create([Bind("PeopleID,Name")] People people)
{
if (ModelState.IsValid)
{
_context.Add(people);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(people));
}
public async Task <IActionResult> Create([Bind("RoomId,Name")] Room room)
{
if (ModelState.IsValid)
{
_context.Add(room);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(room));
}
//[ValidateAntiForgeryToken]
public async Task <IActionResult> Create([Bind("FilmID,Film_ime,Film_trajanje,Film_reziser,Film_opis,Film_img")] Film film)
{
if (ModelState.IsValid)
{
_context.Add(film);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(film));
}
public async Task <IActionResult> Create([Bind("SeatID,Row,Number")] Seat seat)
{
if (ModelState.IsValid)
{
_context.Add(seat);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(seat));
}
public async Task <IActionResult> Create([Bind("MovieID,Title,Rating,Length,StartDate,EndDate,CoverImage")] Movie movie)
{
if (ModelState.IsValid)
{
_context.Add(movie);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public async Task <IActionResult> Create([Bind("PredstavaID,Predstava_cas,FilmID,DvoranaID")] Predstava predstava)
{
if (ModelState.IsValid)
{
_context.Add(predstava);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(predstava));
}
public async Task <ActionResult> Create([Bind(Include = "ID,Name")] Genre genre)
{
if (ModelState.IsValid)
{
db.Genres.Add(genre);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(genre));
}
public async Task <ActionResult> Create([Bind(Include = "ID,Name,Adress")] Venue venue)
{
if (ModelState.IsValid)
{
db.Venues.Add(venue);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(venue));
}
public async Task <IActionResult> Create([Bind("ReservationId,ShowingID,Seats,Price")] Reservation reservation)
{
if (ModelState.IsValid)
{
_context.Add(reservation);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ShowingID"] = new SelectList(_context.showings, "ShowingID", "ShowingID", reservation.ShowingID);
return(View(reservation));
}
public async Task <IActionResult> Create([Bind("GenreMovieID,MovieID,GenreID")] GenreMovie genreMovie)
{
if (ModelState.IsValid)
{
_context.Add(genreMovie);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["GenreID"] = new SelectList(_context.genres, "GenreID", "GenreName", genreMovie.GenreID);
ViewData["MovieID"] = new SelectList(_context.movies, "MovieID", "Title", genreMovie.MovieID);
return(View(genreMovie));
}
public async Task <IActionResult> Create([Bind("DirectorsID,MovieID,PeopleID")] Directors directors)
{
if (ModelState.IsValid)
{
_context.Add(directors);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["MovieID"] = new SelectList(_context.movies, "MovieID", "Title", directors.MovieID);
ViewData["PeopleID"] = new SelectList(_context.people, "PeopleID", "Name", directors.PeopleID);
return(View(directors));
}
public async Task <ActionResult> Create([Bind(Include = "ID,MovieId,VenueId,ScreeningStart,ScreeningEnd,BasePrice,IsPremiere,SubtitleLanguage,Language")] Screening screening)
{
if (ModelState.IsValid)
{
db.Screenings.Add(screening);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.MovieId = new SelectList(db.Movies, "ID", "Title", screening.MovieId);
ViewBag.VenueId = new SelectList(db.Venues, "ID", "Name", screening.VenueId);
return(View(screening));
}
public async Task <IActionResult> Create([Bind("ShowingID,MovieID,RoomID,StartTime")] Showing showing)
{
if (ModelState.IsValid)
{
_context.Add(showing);
await _context.SaveChangesAsync();
/* Dodaj še vse sedeže */
return(RedirectToAction(nameof(Index)));
}
ViewData["MovieID"] = new SelectList(_context.movies, "MovieID", "Title", showing.MovieID);
ViewData["RoomID"] = new SelectList(_context.rooms, "RoomId", "Name", showing.RoomID);
return(View(showing));
}
public async Task <ActionResult <Movie> > AddMovie([FromForm] Movie movie)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (context.Movies.FirstOrDefault(m => m.Title == movie.Title) != null)
{
return(Conflict());
}
context.Add(movie);
await context.SaveChangesAsync();
return(new OkObjectResult(movie));
}
public async Task <ActionResult <ScreeningRoom> > AddScreeningRoom([FromForm] ScreeningRoom room)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (context.ScreeningRooms.FirstOrDefault(sm => sm.Name == room.Name) != null)
{
return(Conflict());
}
context.Add(room);
await context.SaveChangesAsync();
return(new OkObjectResult(room));
}
public async Task <IActionResult> GetReservations()
{
var user = await userManager.GetUserAsync(User);
var reservations = context.Reservations
.Where(r => r.UserId == user.Id)
.Include(r => r.Screening)
.ThenInclude(sc => sc.Movie)
.Include(r => r.Screening)
.ThenInclude(sc => sc.ScreeningRoom)
.ToArray();
var badReservations = reservations.Where(r => r.Expiration.HasValue || !r.IsConfirmed);
context.RemoveRange(badReservations);
await context.SaveChangesAsync();
return(new OkObjectResult(reservations.Where(r => !r.Expiration.HasValue && r.IsConfirmed)));
}
public async Task <IActionResult> ConfirmReservation([FromQuery] int reservationId)
{
var reservation = context.Reservations.FirstOrDefault(r => r.ReservationId == reservationId);
if (reservation == null)
{
return(NotFound());
}
reservation.Expiration = null;
reservation.IsConfirmed = true;
context.Update(reservation);
await context.SaveChangesAsync();
return(Ok());
}
public async Task <ActionResult <UserViewModel> > Register([FromForm] RegisterViewModel registerDetails)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!Role.AllRoles.Contains(registerDetails.Role))
{
return(BadRequest());
}
if (!CheckPasswordRequirements(registerDetails.Password))
{
return(BadRequest());
}
var resultUser = new User
{
UserName = encoder.Encode(registerDetails.Username),
FullName = encoder.Encode(registerDetails.FullName),
};
context.Users.Add(resultUser);
var createResult = await userManager.CreateAsync(resultUser, registerDetails.Password);
if (!createResult.Succeeded)
{
return(BadRequest());
}
var roleResult = await userManager.AddToRoleAsync(resultUser, registerDetails.Role);
if (!roleResult.Succeeded)
{
return(BadRequest());
}
context.Entry(resultUser).State = EntityState.Modified;
await context.SaveChangesAsync();
if (resultUser != null)
{
return(new OkObjectResult(new UserViewModel(resultUser, encoder, registerDetails.Role)));
}
else
{
return(BadRequest());
}
}
public void Add(Seanse seanse)
{
_context.Add(seanse);
_context.SaveChangesAsync();
}