public async Task <IActionResult> PutCinema(int id, Cinema cinema)
{
if (id != cinema.Id)
{
return(BadRequest());
}
_context.Entry(cinema).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CinemaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <inheritdoc cref="ICreatable{TDto, TModel}.CreateAsync(TDto)"/>
public async Task <TDto> CreateAsync(TDto dto)
{
var entity = _mapper.Map <TModel>(dto);
await DbSet.AddAsync(entity);
await _context.SaveChangesAsync();
return(await GetAsync(entity.Id));
}
public async Task DeleteAsync(ID id)
{
var hall = await GetAsync(id);
if (hall != null)
{
_context.Halls.Remove(hall);
await _context.SaveChangesAsync();
}
}
public async Task DeleteAsync(ID id)
{
var movie = await GetAsync(id);
if (movie != null)
{
_context.Movies.Remove(movie);
await _context.SaveChangesAsync();
}
}
public async Task DeleteAsync(ID id)
{
var cinema = await GetAsync(id);
if (cinema != null)
{
_context.Cinemas.Remove(cinema);
await _context.SaveChangesAsync();
}
}
public async Task <IActionResult> Create([Bind("Id,Name,FilmStartTime")] FilmShow filmShow)
{
if (ModelState.IsValid)
{
_context.Add(filmShow);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(filmShow));
}
public async Task <IActionResult> Create([Bind("ID,Seats")] Auditorium auditorium)
{
if (ModelState.IsValid)
{
_context.Add(auditorium);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(auditorium));
}
public async Task <IActionResult> Create([Bind("Id,Image,Title,ReleaseDate,Genre,Rating,Description,Video")] Movie movie)
{
if (ModelState.IsValid)
{
_context.Add(movie);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public async Task <IActionResult> Create([Bind("Id,Name,Rating,Price,Time")] Cinema cinema)
{
if (ModelState.IsValid)
{
_context.Add(cinema);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(cinema));
}
public async Task <IActionResult> Create([Bind("ActorID,Name,BirthDate,BirthPlace")] Actor actor)
{
if (ModelState.IsValid)
{
_context.Add(actor);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(actor));
}
public async Task <IActionResult> Create([Bind("ID,Name,Length")] Movie movie)
{
if (ModelState.IsValid)
{
_context.Add(movie);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public async Task <IActionResult> Create([Bind("ID,ShowingID,Seat,Booked")] ShowingSeat showingSeat)
{
if (ModelState.IsValid)
{
_context.Add(showingSeat);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ShowingID"] = new SelectList(_context.Showings, "ID", "ID", showingSeat.ShowingID);
return(View(showingSeat));
}
public async Task <IActionResult> Create([Bind("ID,StartTime,MovieID,LoungeID,SeatsLeft")] Showing showing)
{
if (ModelState.IsValid)
{
_context.Add(showing);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["LoungeID"] = new SelectList(_context.Lounges, "ID", "ID", showing.LoungeID);
ViewData["MovieID"] = new SelectList(_context.Movies, "ID", "ID", showing.MovieID);
return(View(showing));
}
public async Task <IActionResult> Create([Bind("MovieID,Title,CategoryID,StudioID,FilmDirector,ReleaseDate,BoxOffice")] Movie movie)
{
if (ModelState.IsValid)
{
_context.Add(movie);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CategoryID"] = new SelectList(_context.Categories, "CategoryID", "CategoryID", movie.CategoryID);
ViewData["StudioID"] = new SelectList(_context.Studios, "StudioID", "StudioID", movie.StudioID);
return(View(movie));
}
public async Task <IActionResult> Create([Bind("BookTicketID,MovieID,HallID")] BookTicket bookTicket)
{
if (ModelState.IsValid)
{
_context.Add(bookTicket);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["HallID"] = new SelectList(_context.Halls, "Id", "Id", bookTicket.HallID);
ViewData["MovieID"] = new SelectList(_context.Movies, "Id", "Title", bookTicket.MovieID);
return(View(bookTicket));
}
public async Task <IActionResult> Create([Bind("ID,SeatsLeft,Time,MovieID,AuditoriumID")] Viewing viewing)
{
if (ModelState.IsValid)
{
_context.Add(viewing);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["AuditoriumID"] = new SelectList(_context.Auditoriums, "ID", "ID", viewing.AuditoriumID);
ViewData["MovieID"] = new SelectList(_context.Movies, "ID", "ID", viewing.MovieID);
return(View(viewing));
}
public async Task <ActionResult <FilmOrder> > PostFilmOrder(FilmOrder filmOrder)
{
_context.FilmOrders.Add(filmOrder);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetFilmOrder", new { id = filmOrder.Id }, filmOrder));
}
public async Task <IActionResult> SellTickets([FromBody] ReservationDto newReserve)
{
try
{
if (ModelState.IsValid)
{
var seats = _context.Seats.Where(o => newReserve.SelectedSeats.Contains(o.Id));
foreach (var seat in seats)
{
seat.State = State.Sold;
seat.NameReserved = newReserve.Name;
seat.PhoneNum = newReserve.PhoneNum;
}
_context.UpdateRange(seats);
await _context.SaveChangesAsync();
}
else
{
return(BadRequest());
}
}
catch (Exception e)
{
BadRequest();
}
return(Ok());
}
public async Task <ActionResult> UpdateSeats([FromBody] List <Seat> seats)
{
foreach (var seat in seats)
{
seat.IsBooked = true;
_context.Entry(seat).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SeatExists(seat.Id))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(NoContent());
}
public async Task <IActionResult> Create([Bind("MovieGenre")] Category category)
{
try
{
if (ModelState.IsValid)
{
_context.Add(category);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException /* ex*/)
{
ModelState.AddModelError("", "Unable to save changes. " + "Try again, and if the problem persists ");
}
return(View(category));
}
public string Delete(string id)
{
FilmInfo film = cinemaContext.FilmInfo.FirstOrDefault(x => x.Id.ToString().Equals(id));
if (film == null)
{
return(JsonConvert.SerializeObject("Фильм не найден!"));
}
cinemaContext.FilmInfo.Remove(film);
cinemaContext.SaveChangesAsync();
return(JsonConvert.SerializeObject("Успешно удален!"));
}
public string Delete(string id)
{
HallInfo hall = cinemaContext.HallInfo.FirstOrDefault(x => x.Id.ToString().Equals(id));
if (hall == null)
{
return(JsonConvert.SerializeObject("Зал не найден!"));
}
cinemaContext.HallInfo.Remove(hall);
cinemaContext.SaveChangesAsync();
return(JsonConvert.SerializeObject("Успешно удален!"));
}
public string Delete(string id)
{
CinemaInfo cinema = cinemaContext.CinemaInfo.FirstOrDefault(x => x.Id.ToString().Equals(id));
if (cinema == null)
{
return(JsonConvert.SerializeObject("Кинотеатр не найден!"));
}
cinemaContext.CinemaInfo.Remove(cinema);
cinemaContext.SaveChangesAsync();
return(JsonConvert.SerializeObject("Успешно удален!"));
}
public async Task <IActionResult> Reservation(int cinemaId, int hallId, int seatRow, int seatPlace, double phone)
{
var seats = await GetSeatsByCinemaIdAndHallId(cinemaId, hallId);
var seat = seats.FirstOrDefault(s => s.Row == seatRow && s.Place == seatPlace);
if (seat == null)
{
NotFound("Seat not exist");
}
if (seat.IsReserved)
{
BadRequest("Seat already reserved");
}
seat.IsReserved = true;
seat.PlaceHolderPhone = phone;
_context.Seats.Update(seat);
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> PutBooking(int id, BookingDTO booking)
{
if (id != booking.ID)
{
return(BadRequest());
}
if (!BookingExists(id))
{
return(NotFound());
}
_context.Entry(booking).State = EntityState.Modified;
if ((booking.Seats.Equals(null)))
{
_context.Entry(booking).Property("Seats").IsModified = false;
}
if (booking.TimeSlot.Equals(null))
{
_context.Entry(booking).Property("TimeSlot").IsModified = false;
}
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <IActionResult> Reserve(ReservationViewModel reservationViewModel)
{
if (ModelState.IsValid)
{
var ids = reservationViewModel.SeatIds.Split(",");
var selectedSeats = from m in _context.Seats where ids.Contains(m.Id.ToString()) select m;
foreach (var current in selectedSeats)
{
if (current.State != State.Free)
{
return(NotFound());
}
current.State = State.Reserved;
current.NameReserved = reservationViewModel.Name;
current.PhoneNum = reservationViewModel.PhoneNumber;
}
_context.UpdateRange(selectedSeats);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(HomeController.Index)));
}
var selectedShow = await _context.Shows
.FirstOrDefaultAsync(m => m.Id == reservationViewModel.ShowId);
if (selectedShow == null)
{
return(NotFound());
}
var thisShowRoom = await _context.Rooms
.FirstOrDefaultAsync(m => m.Id == selectedShow.RoomRefId);
if (thisShowRoom == null)
{
return(NotFound());
}
var thisShowSeats = from m in _context.Seats where m.ShowRefId == reservationViewModel.ShowId
select m;
reservationViewModel.Room = thisShowRoom;
reservationViewModel.Seats = await thisShowSeats.ToListAsync();
reservationViewModel.SeatIds = "";
return(View(reservationViewModel));
}
public async Task <IActionResult> FinalizeBooking(int id, [Bind("Id,StartTime,MovieId,MovieTitle, SalonId, Salon")] Viewing receivedModel)
{
if (id != receivedModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var salonFromDb = await _context.SalonList.Where(s => s.Id == receivedModel.SalonId).ToListAsync();
var salon = (Salon)salonFromDb[0];
if (salon.RemainingSeats <= 0)
{
return(View("BookTicketView", receivedModel));
}
salon.RemainingSeats -= receivedModel.Salon.RemainingSeats;
receivedModel.Salon = salon;
try
{
_context.Update(salon);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(receivedModel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("BookingConfirmation", receivedModel));
}
return(View("BookTicketView", receivedModel));
}
public async Task <string> Post([FromBody] SeanceData value)
{
Seance seance = new Seance();
Guid guid = Guid.NewGuid();
DateTime startDate = DateTime.ParseExact(value.StartTime.Replace(' ', 'T'), "yyyy-MM-ddTHH:mm:ss", null);
DateTime endDate = DateTime.ParseExact(value.EndTime.Replace(' ', 'T'), "yyyy-MM-ddTHH:mm:ss", null);
using var db = new CinemaContext();
{
if ((await db.Seance.Where(x => x.HallId == value.HallId).ToListAsync())?.All(x => startDate.CompareTo(x.StartTime) == -1 && endDate.CompareTo(x.StartTime) == -1 ||
startDate.CompareTo(x.EndTime) == 1) == true) //&& !db.Seance.Any(u=>u.HallId.Equals(value.HallId)))
{
seance.StartTime = DateTime.ParseExact(value.StartTime, "yyyy-MM-dd HH:mm:ss", null);
seance.EndTime = DateTime.ParseExact(value.EndTime, "yyyy-MM-dd HH:mm:ss", null);
seance.HallId = value.HallId;
seance.FilmId = value.FilmId;
seance.Id = guid;
seance.TicketPrice = value.TicketPrice;
try
{
cinemaContext.Add(seance);
await cinemaContext.SaveChangesAsync();
return(guid.ToString());
}
catch (Exception ex)
{
return(JsonConvert.SerializeObject(ex.Message));
}
}
else
{
return("Сеанс уже существует");
}
}
}
/// <summary>
/// Процессинг нового заказа
/// </summary>
/// <param name="orderDto">DTO-объект с информацией по заказу</param>
/// <returns>Статус обработки заказа</returns>
public async Task <bool> ProcessPlacedOrder(OrderDto orderDto)
{
try
{
User user = await _context
.Users
.FirstOrDefaultAsync(u => u.Id == orderDto.UserId);
if (user == null)
{
_logger.Information($"Неизвестный пользователь с id = {orderDto.UserId}");
return(false);
}
OrderStatus orderStatus = await _context
.OrderStatuses
.FirstOrDefaultAsync(o => o.Status == OrderCreated);
if (orderStatus == null)
{
_logger.Information("Неизвестный статус заказа");
return(false);
}
Order order = new Order
{
ModifyDate = DateTime.Now,
OrderStatus = orderStatus,
User = user
};
foreach (var sessionId in orderDto.SessionIds)
{
Session session = await _context
.Sessions
.Include(s => s.OrderSessions)
.FirstOrDefaultAsync(s => s.Id == sessionId);
if (session == null || session.FreeSeats <= 0)
{
_logger.Information("Сеанс не найден или закончились места");
continue;
}
session.OrderSessions.Add(new OrderSession
{
Order = order,
Session = session
});
session.FreeSeats--;
}
await _context.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
_logger.Information($"Ошибка во время создания заказа. {e.Message}");
return(false);
}
}
public void CommitAsync()
{
dataContext.SaveChangesAsync();
}
