public async Task InsertAsync(IProjectionCreation proj)
{
Projection newProj = new Projection(proj.MovieId, proj.RoomId, proj.StartDate, proj.AvailableSeatsCount);
db.Projections.Add(newProj);
await db.SaveChangesAsync();
}
public void Insert(IProjectionCreation proj)
{
Projection newProj = new Projection(proj.MovieId, proj.RoomId, proj.StartDate, proj.AvailableSeatsCount);
db.Projections.Add(newProj);
db.SaveChanges();
}
public async Task <NewSummary> New(IProjectionCreation projection)
{
await projectionsRepo.Insert(new Projection(projection.MovieId, projection.RoomId, projection.StartDate));
//DONE: Add appropriate message. In the controller.
return(new NewSummary(true));
}
public NewProjectionSummary New(IProjectionCreation proj)
{
if (proj.AvailableSeatsCount < 0)
{
return(new NewProjectionSummary(false, "Available seats can not be less than zero!"));
}
return(newProj.New(proj));
}
public async Task <NewSummary> New(IProjectionCreation proj)
{
if (proj.AvailableSeatsCount < 0)
{
return(new NewSummary(false, StringConstants.NegativeSeat));
}
return(await newProj.New(proj));
}
public async Task <NewProjectionSummary> NewAsync(IProjectionCreation projection)
{
var currRoom = await roomRepo.GetByIdAsync(projection.RoomId);
var availableSeatsCount = currRoom.Rows * currRoom.SeatsPerRow;
await projectionsRepo.InsertAsync(new Projection(projection.MovieId, projection.RoomId, projection.StartDate, availableSeatsCount));
return(new NewProjectionSummary(true));
}
public async Task <NewProjectionSummary> NewAsync(IProjectionCreation projection)
{
if (projection.AvailableSeatsCount < 0)
{
var constraintMessage = "AvailableSeatsCount can not accept negative values.";
return(new NewProjectionSummary(false, constraintMessage));
}
return(await newProj.NewAsync(projection));
}
public NewCreationSummary New(IProjectionCreation projection)
{
if (projection.AvailableSeatsCount < 0)
{
return(new NewCreationSummary(false, "Available seats count cannot be negative number"));
}
projectionsRepo.Insert(new Projection(projection.MovieId, projection.RoomId, projection.StartDate, projection.AvailableSeatsCount));
return(new NewCreationSummary(true));
}
public async Task <NewSummary> New(IProjectionCreation proj)
{
IProjection projection = await projectRepo.Get(proj.MovieId, proj.RoomId, proj.StartDate);
if (projection != null)
{
return(new NewSummary(false, StringConstants.ProjectionExists));
}
return(await newProj.New(proj));
}
public async Task <NewProjectionSummary> NewAsync(IProjectionCreation projection)
{
IMovie movie = await movieRepo.GetByIdAsync(projection.MovieId);
if (movie == null)
{
return(new NewProjectionSummary(false, $"Movie with id {projection.MovieId} does not exist"));
}
return(await newProj.NewAsync(projection));
}
public async Task <NewProjectionSummary> NewAsync(IProjectionCreation proj)
{
IProjection projection = await projectRepo.GetAsync(proj.MovieId, proj.RoomId, proj.StartDate);
if (projection != null)
{
return(new NewProjectionSummary(false, "Projection already exists"));
}
return(await newProj.NewAsync(proj));
}
public async Task <NewSummary> New(IProjectionCreation proj)
{
IRoom room = await this.roomRepo.GetById(proj.RoomId);
if (room == null)
{
return(new NewSummary(false, $"Room with id {proj.RoomId} does not exist"));
}
return(await newProj.New(proj));
}
public NewProjectionSummary New(IProjectionCreation proj)
{
IProjection projection = projectRepo.Get(proj.MovieId, proj.RoomId, proj.StartDate, proj.AvailableSeatsCount);
if (projection != null)
{
return(new NewProjectionSummary(false, "Projection already exists"));
}
return(newProj.New(proj));
}
public NewProjectionSummary New(IProjectionCreation proj)
{
IRoom room = roomRepo.GetById(proj.RoomId);
if (room == null)
{
return(new NewProjectionSummary(false, $"Room with id {proj.RoomId} does not exist"));
}
return(newProj.New(proj));
}
public NewProjectionSummary New(IProjectionCreation projection)
{
if (projection.AvailableSeatsCount < 0)
{
return(new NewProjectionSummary(false, $"It sucks to eat popcorns, standing up ;) Cinema needs seats!"));
}
projectionsRepo.Insert(new Projection(projection.MovieId, projection.RoomId, projection.StartDate, projection.AvailableSeatsCount));
return(new NewProjectionSummary(true));
}
public NewProjectionSummary New(IProjectionCreation projection)
{
IMovie movie = movieRepo.GetById(projection.MovieId);
if (movie == null)
{
return(new NewProjectionSummary(false, $"Movie with id {projection.MovieId} does not exist"));
}
return(newProj.New(projection));
}
public async Task <NewSummary> New(IProjectionCreation projection)
{
DateTime currentTime = DateTime.Now;
DateTime projCreationTime = projection.StartDate;
if (currentTime > projCreationTime)
{
return(new NewSummary(false, "You cannot create projections in the past!"));
}
return(await newProj.New(projection));
}
public NewProjectionSummary New(IProjectionCreation projection)
{
if (projection.AvailableSeatsCount < 0)
{
return(new NewProjectionSummary(false, "Projection seats must be a positive number!"));
}
projectionsRepo.Insert(new Projection(projection.MovieId, projection.RoomId,
projection.StartDate, projection.AvailableSeatsCount));
return(new NewProjectionSummary(true));
}
public async Task Insert(IProjectionCreation proj)
{
Projection newProj = new Projection(proj.MovieId, proj.RoomId, proj.StartDate);
//Initializes initial available seats which should be equal to all seats in the current room.
newProj.AvailableSeatsCount = InitialSeats(proj.RoomId);
//Initialize end date.
newProj.EndDate = CalculateEndDate(proj.MovieId, proj.StartDate);
db.Projections.Add(newProj);
await db.SaveChangesAsync();
}
public NewProjectionSummary New(IProjectionCreation proj)
{
IEnumerable <IProjection> movieProjectionsInRoom = projectRepo.GetActiveProjections(proj.RoomId);
IProjection previousProjection = movieProjectionsInRoom.Where(x => x.StartDate < proj.StartDate)
.OrderByDescending(x => x.StartDate)
.FirstOrDefault();
if (previousProjection != null)
{
IMovie previousProjectionMovie = movieRepo.GetById(previousProjection.MovieId);
DateTime previousProjectionEnd = previousProjection.StartDate.AddMinutes(previousProjectionMovie.DurationMinutes);
if (previousProjectionEnd >= proj.StartDate)
{
return(new NewProjectionSummary(false, $"Projection overlaps with previous one: {previousProjectionMovie.Name} at {previousProjection.StartDate}"));
}
}
return(newProj.New(proj));
}
public NewCreationSummary New(IProjectionCreation proj)
{
IEnumerable <IProjection> movieProjectionsInRoom = projectRepo.GetActiveProjections(proj.RoomId);
IProjection nextProjection = movieProjectionsInRoom.Where(x => x.StartDate > proj.StartDate)
.OrderBy(x => x.StartDate)
.FirstOrDefault();
if (nextProjection != null)
{
IMovie curMovie = movieRepo.GetById(proj.MovieId);
IMovie nextProjectionMovie = movieRepo.GetById(nextProjection.MovieId);
DateTime curProjectionEndTime = proj.StartDate.AddMinutes(curMovie.DurationMinutes);
if (curProjectionEndTime >= nextProjection.StartDate)
{
return(new NewCreationSummary(false, $"Projection overlaps with next one: {nextProjectionMovie.Name} at {nextProjection.StartDate}"));
}
}
return(newProj.New(proj));
}
public NewProjectionSummary New(IProjectionCreation projection)
{
projectionsRepo.Insert(new Projection(projection.MovieId, projection.RoomId, projection.StartDate));
return(new NewProjectionSummary(true));
}
