public async Task <NewTicketSummary> New(ITicketCreation ticket)
{
IProjection projection = await this.projRepo.GetById(ticket.ProjectionId);
await this.projRepo.DecreaseAvailableSeats(projection.Id);
string movieName = await this.movieRepo.GetMovieNameById(projection.MovieId);
var room = await this.roomRepo.GetById(projection.RoomId);
var cinemaName = await this.cinemaRepo.GetCinemaNameById(room.CinemaId);
await this.ticketRepo.Insert(
new Ticket(
projection.StartDate,
movieName,
cinemaName,
room.Number,
ticket.Row,
ticket.Column,
projection.Id));
//TODO: remove message?
return(new NewTicketSummary(true, StringConstants.TicketCreated));
}
public async Task <NewTicketSummary> NewAsync(ITicketCreation reservation)
{
ITicket newTicket = await ticketRepo.InsertAsync(
new Ticket(
reservation.ProjectionId,
reservation.Row,
reservation.Column));
await projectionRepo.DecreaseAvailableSeatsAsync(reservation.ProjectionId);
//preparing data for ticketOutputReceipt
var currProjection = await projectionRepo.GetProjectionByIdAsync(newTicket.ProjectionId);
var currMovie = await movieRepo.GetByIdAsync(currProjection.MovieId);
var currRoom = await roomRepo.GetByIdAsync(currProjection.RoomId);
var currCinema = await cinemaRepo.GetByIdAsync(currRoom.CinemaId);
TicketOutputReceipt ticketOutputReceipt = new TicketOutputReceipt(
newTicket.Id,
currProjection.StartDate,
currMovie.Name, currCinema.Name,
currRoom.Number,
newTicket.Row,
newTicket.Column);
return(new NewTicketSummary(true, ticketOutputReceipt));
}
public ITicket Insert(ITicketCreation ticket)
{
Ticket newTicket = new Ticket(
ticket.ProjectionId,
ticket.Guid,
ticket.ProjectionStartDate,
ticket.MovieName,
ticket.CinemaName,
ticket.RoomNum,
ticket.Row,
ticket.Column
);
db.Tickets.Add(newTicket);
db.Projections
.Where(p => p.Id == ticket.ProjectionId)
.ToList()
.ForEach(x => x.AvailableSeatsCount--);
db.SaveChanges();
return(newTicket);
}
public void Insert(ITicketCreation ticket)
{
Ticket newTicket = new Ticket(ticket.ProjectionId, ticket.Row, ticket.Column);
db.Tickets.Add(newTicket);
db.SaveChanges();
id = newTicket.Id;
}
public async Task <ITicket> InsertAsync(ITicketCreation ticket)
{
Ticket newTicket = new Ticket(ticket.ProjectionId, ticket.Row, ticket.Column);
Ticket savedTicket = db.Tickets.Add(newTicket);
await db.SaveChangesAsync();
return(savedTicket);
}
public async Task <ITicket> Insert(ITicketCreation ticket)
{
Ticket newTicket = new Ticket(ticket.ProjectionStartDate, ticket.Movie, ticket.Cinema, ticket.Room, ticket.Row, ticket.Column, ticket.ProjectionId);
db.Tickets.Add(newTicket);
await db.SaveChangesAsync();
return(newTicket);
}
public async Task <NewTicketSummary> New(ITicketCreation model)
{
IProjection projection = await this.projRepo.GetById(model.ProjectionId);
if (DateTime.Now > projection.StartDate)
{
return(new NewTicketSummary(false, StringConstants.MovieStarted));
}
return(await newTicket.New(model));
}
public async Task <NewCreationSummary> New(ITicketCreation ticket)
{
DateTime currentDate = DateTime.UtcNow;
if (currentDate > ticket.ProjectionStartDate)
{
return(new NewCreationSummary(false, "Cannot buy seats for finished projection"));
}
return(await newTicket.New(ticket));
}
public async Task <NewCreationSummary> New(ITicketCreation ticket)
{
ITicket ticketDb = ticketRepo.Get(ticket.Row, ticket.Column, ticket.ProjectionId);
if (ticketDb != null)
{
return(new NewCreationSummary(false, "The seats are already bought"));
}
return(await newTicket.New(ticket));
}
public async Task <NewTicketSummary> New(ITicketCreation model)
{
IProjection projection = await this.projRepo.GetById(model.ProjectionId);
if (projection == null)
{
return(new NewTicketSummary(false, $"Projection with id {model.ProjectionId} does not exist"));
}
return(await newTicket.New(model));
}
public async Task <NewCreationSummary> New(ITicketCreation ticket)
{
IReservation reservationDb = await reserveRepo.Get(ticket.Row, ticket.Column, ticket.ProjectionId);
if (reservationDb != null)
{
return(new NewCreationSummary(false, "Cannot buy reserved seats"));
}
return(await newTicket.New(ticket));
}
public async Task <NewCreationSummary> New(ITicketCreation ticket)
{
DateTime currentDate = DateTime.UtcNow;
TimeSpan ts = ticket.ProjectionStartDate - currentDate;
if (ts.TotalMinutes > 0 && ts.TotalMinutes < 10)
{
return(new NewCreationSummary(false, "Cannot buy seats with reservation for projection starting in less than 10 minutes"));
}
return(await newTicket.New(ticket));
}
public NewTicketSummary New(ITicketCreation ticket)
{
IProjection projection = projRepo.GetById(ticket.ProjectionId);
DateTime now = DateTime.UtcNow;
if (projection.StartDate < now)
{
return(new NewTicketSummary(false, "You have to purchase a ticket before beginning of the projection!"));
}
return(_newTicketNoRes.New(ticket));
}
public async Task <NewTicketSummary> NewAsync(ITicketCreation ticket)
{
var currProjection = await projectionsRepo.GetProjectionByIdAsync(ticket.ProjectionId);
if (currProjection.StartDate <= DateTime.Now)
{
var constraintMessage = "It is too late to buy tickets for this projection! Seats are no longer available.";
return(new NewTicketSummary(false, constraintMessage));
}
else
{
return(await newTicket.NewAsync(ticket));
}
}
public async Task <NewCreationSummary> New(ITicketCreation ticket)
{
var reservations = await reserveRepo.GetAllReservations();
await reserveRepo.CancelExpiredReservations(reservations);
var reservationDb = await reserveRepo.Get(ticket.Row, ticket.Column, ticket.ProjectionId);
if (reservationDb == null)
{
return(new NewCreationSummary(false, "Cannot buy seats for expired reservation"));
}
return(await newTicket.New(ticket));
}
public async Task <NewTicketSummary> New(ITicketCreation ticket)
{
var projection = await this.projRepo.GetById(ticket.ProjectionId);
var room = await this.roomRepo.GetById(projection.RoomId);
if (ticket.Row < 0 || ticket.Row > room.SeatsPerRow ||
ticket.Column < 0 || ticket.Column > room.Rows)
{
return(new NewTicketSummary(false, $"Seat with position row: {ticket.Row}" +
$" and column: {ticket.Column} does not exist"));
}
return(await newTicket.New(ticket));
}
public NewTicketSummary New(ITicketCreation ticket)
{
IEnumerable <IReservation> reservedSeats = ticketRepo.GetReservedSeats(ticket.ProjectionId);
IEnumerable <ITicket> purchasedSeats = ticketRepo.GetPurchasedSeats(ticket.ProjectionId);
bool checkReservations = reservedSeats.Any(x => x.Row == ticket.Row && x.Column == ticket.Column);
bool checkTickets = purchasedSeats.Any(x => x.Row == ticket.Row && x.Column == ticket.Column);
if (checkReservations || checkTickets)
{
return(new NewTicketSummary(false, "This seat is reserved"));
}
return(_newTicketNoRes.New(ticket));
}
public async Task Insert(ITicketCreation ticket)
{
Ticket newTicket = new Ticket(
ticket.ProjectionStartDate,
ticket.MovieName,
ticket.CinemaName,
ticket.RoomNumber,
ticket.Row,
ticket.Column,
ticket.ProjectionId);
this.db.Tickets.Add(newTicket);
await this.db.SaveChangesAsync();
}
public async Task <NewCreationSummary> New(ITicketCreation ticket)
{
var reservations = await reserveRepo.GetAllReservations();
await reserveRepo.CancelExpiredReservations(reservations);
DateTime currentDate = DateTime.UtcNow;
TimeSpan ts = ticket.ProjectionStartDate - currentDate;
if (ts.TotalMinutes > 0 && ts.TotalMinutes < 10)
{
return(new NewCreationSummary(false, "Cannot buy seats for projection starting in less than 10 minutes"));
}
return(await newTicket.New(ticket));
}
public async Task <NewTicketSummary> NewAsync(ITicketCreation ticket)
{
var existinglReservation = await reservationRepo
.GetAsync(ticket.ProjectionId, ticket.Row, ticket.Column);
var existingTicket = await ticketRepo.GetAsync(ticket.ProjectionId, ticket.Row, ticket.Column);
if (existinglReservation != null || existingTicket != null)
{
var constraintMessage = "This seat is not available! You can not buy ticket for it";
return(new NewTicketSummary(false, constraintMessage));
}
else
{
return(await newTicket.NewAsync(ticket));
}
}
public async Task <NewTicketSummary> New(ITicketCreation ticket)
{
IProjection projection = await this.projRepo.GetById(ticket.ProjectionId);
DateTime projectionStartdate = await this.projRepo.GetProjectionStartDate(projection.Id);
if (DateTime.Now.AddMinutes(10) >= projectionStartdate)
{
int count = await this.reservationRepository.RemoveAllReservations(projection.Id);
await this.projRepo.IncreaseAvailableSeats(projection.Id, count);
}
bool available = await this.projRepo.CheckIfSeatIsAvailable
(ticket.ProjectionId, ticket.Row, ticket.Column);
if (available == false)
{
return(new NewTicketSummary(false, StringConstants.OccupiedPlace));
}
return(await newTicket.New(ticket));
}
public TicketReturnObject Insert(ITicketCreation ticket)
{
Ticket newTicket = new Ticket(ticket.ProjectionStartDate,
ticket.MovieName, ticket.CinemaName, ticket.RoomNumber, ticket
.Row, ticket.Col, ticket.ProjectionId);
var projection = (Projection)this.projectionRepository.GetProjectionById(ticket.ProjectionId);
db.Tickets.Add(newTicket);
projection.AvailableSeatsCount--;
db.SaveChanges();
return(new TicketReturnObject
{
TicketUniqueKey = newTicket.Id,
ProjectionStartDate = newTicket.ProjectionStartDate,
MovieName = newTicket.MovieName,
CinemaName = newTicket.CinemaName,
RoomNumber = newTicket.RoomNumber,
Row = newTicket.Row,
Column = newTicket.Col
});
}
public NewTicketSummary New(ITicketCreation ticket)
{
ticketsRepo.Insert(new Ticket(ticket.ProjectionId, ticket.Row, ticket.Column));
return(new NewTicketSummary(true));
}
//private readonly ITicketRepository ticketRepo;
//private readonly INewTicketNoRes newRes;
//public NewTicketNoResExistingSeatsValidation(IReservationRepository reservationRepo, INewReservation newRes)
//{
// this.reservationRepo = reservationRepo;
// this.newRes = newRes;
//}
//public NewReservationSummary New(IReservationCreation reservation)
//{
// IRoom room = ticketRepo.GetRoomById(reservation.ProjectionId);
// bool checkSeatExistence = room.Rows < reservation.Row ||
// room.SeatsPerRow < reservation.Column ||
// reservation.Row <= 0 ||
// reservation.Column <= 0;
// if (checkSeatExistence)
// {
// return new NewReservationSummary(false, "This seat does not exist");
// }
// return newRes.New(reservation);
//}
public NewTicketSummary New(ITicketCreation ticket)
{
throw new System.NotImplementedException();
}
public async Task <NewCreationSummary> New(ITicketCreation ticket)
{
await ticketRepo.Insert(new Ticket(ticket.ProjectionStartDate, ticket.Movie, ticket.Cinema, ticket.Room, ticket.Row, ticket.Column, ticket.ProjectionId));
return(new NewCreationSummary(true));
}
