public async Task <ReservationServiceModel> MakeReservation(CreateReservationBindingModel viewModel, ReserveTableUserServiceModel user, RestaurantServiceModel restaurant)
{
var dateTime = DateTime.Parse(viewModel.Date + " " + viewModel.Time);
var tablesWithExactCountSeats = restaurant.Tables
.Where(t => t.SeatsCount == viewModel.SeatsCount)
.ToList();
var tablesWithSeatsCountPlusOne = restaurant.Tables
.Where(t => t.SeatsCount == viewModel.SeatsCount + 1)
.ToList();
ReservationServiceModel reservationServiceModel = new ReservationServiceModel();
if (tablesWithExactCountSeats.Any())
{
foreach (var table in tablesWithExactCountSeats)
{
return(await FindTable(viewModel, user, restaurant, dateTime, reservationServiceModel, table));
}
}
else if (tablesWithSeatsCountPlusOne.Any())
{
foreach (var biggerTable in tablesWithSeatsCountPlusOne)
{
return(await FindTable(viewModel, user, restaurant, dateTime, reservationServiceModel, biggerTable));
}
}
return(null);
}
public async Task <IActionResult> Create(string city, string restaurant, CreateReservationBindingModel viewModel)
{
var dateTime = DateTime.Parse(viewModel.Date + " " + viewModel.Time);
var isDateValid = await reservationsService.IsDateValid(dateTime);
if (isDateValid)
{
RestaurantServiceModel restaurantFromDb = await restaurantService.GetRestaurantByNameAndCity(city, restaurant);
ReserveTableUserServiceModel user = await usersService.GetUserByUsername(this.User.Identity.Name);
ReservationServiceModel reservation = await reservationsService.MakeReservation(viewModel, user, restaurantFromDb);
if (reservation == null)
{
ModelState.AddModelError("NoAvailableTables", "There are no available tables.");
return(this.View());
}
return(this.Redirect("/Reservations/My"));
}
else
{
ModelState.AddModelError("InvalidData", "Your date is not valid.");
}
return(this.View());
}
private static void InitializeReservation(CreateReservationBindingModel viewModel, ReserveTableUserServiceModel user, RestaurantServiceModel restaurant, DateTime dateTime, ReservationServiceModel reservationServiceModel, TableServiceModel table)
{
reservationServiceModel.ForDate = dateTime;
reservationServiceModel.SeatsCount = viewModel.SeatsCount;
reservationServiceModel.UserId = user.Id;
reservationServiceModel.TableId = table.Id;
reservationServiceModel.RestaurantId = restaurant.Id;
}
public async Task <IHttpActionResult> Make(CreateReservationBindingModel model)
{
var result = await this.service.MakeReservation(model);
if (!result.IsSuccessful)
{
return(BadRequest(result.Message));
}
return(Ok(result.ReservationTicket));
}
public async Task MakeReservation_WithNoAvailableTables_ShouldReturnNull()
{
string errorMessage = "ReservationService MakeReservation() method does not work properly.";
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
this.reservationService = new ReservationService(context);
await SeedData(context);
CreateReservationBindingModel reservationBindingModel = new CreateReservationBindingModel
{
Date = "09/08/2019 20:00:00",
SeatsCount = 4,
Restaurant = "Happy"
};
ReserveTableUserServiceModel user = new ReserveTableUserServiceModel
{
Id = "1",
Email = "*****@*****.**",
UserName = "******"
};
RestaurantServiceModel restaurant = new RestaurantServiceModel
{
Id = "1",
Address = "New Street",
AverageRating = 10,
CityId = "1",
Name = "Happy",
PhoneNumber = "0888888888",
Photo = "/src/happy.jpg",
Tables = new List <TableServiceModel>()
{
new TableServiceModel
{
Id = "1",
SeatsCount = 2,
RestaurantId = "1",
Reservations = new List <ReservationServiceModel>()
}
}
};
var actualResult = await reservationService.MakeReservation(reservationBindingModel, user, restaurant);
Assert.True(actualResult == null, errorMessage);
}
private async Task <ReservationServiceModel> FindTable(CreateReservationBindingModel viewModel, ReserveTableUserServiceModel user, RestaurantServiceModel restaurant, DateTime dateTime, ReservationServiceModel reservationServiceModel, TableServiceModel table)
{
if (table.Reservations.Any(t => (dateTime > t.ForDate && dateTime < t.EndOfReservation) && t.IsCancelled == false))
{
return(null);
}
else
{
InitializeReservation(viewModel, user, restaurant, dateTime, reservationServiceModel, table);
var reservation = AutoMapper.Mapper.Map <Reservation>(reservationServiceModel);
await dbContext.Reservations.AddAsync(reservation);
await dbContext.SaveChangesAsync();
return(reservationServiceModel);
}
}
public IHttpActionResult PostReservation(CreateReservationBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (unitOfWork.AccountsForApprove.Find(a => a.UserId == UserManager.FindById(User.Identity.GetUserId()).Id).Count() > 0)
{
return(BadRequest("Your account is not approved."));
}
Vehicle vehicle = unitOfWork.Vehicles.Get(model.VehicleId);
if (vehicle == null)
{
return(BadRequest("Non-existent vehicle."));
}
if (!vehicle.IsAvailable)
{
return(BadRequest("Vehicle is unavailable."));
}
if (model.ReservationStart >= model.ReservationEnd)
{
BadRequest("Reservation start date and time must be greater than reservation end date and time.");
}
if (model.ReservationStart < DateTime.Now)
{
BadRequest("Reservation start date and time must be greater than current date and time.");
}
if (model.ReservationEnd < DateTime.Now)
{
BadRequest("Reservation end date and time must be greater than current date and time.");
}
BranchOffice rentBranchOffice = unitOfWork.BranchOffices.Get(model.RentBranchOfficeId);
if (rentBranchOffice == null)
{
BadRequest("Non-existent rent branch office.");
}
BranchOffice returnBranchOffice = unitOfWork.BranchOffices.Get(model.ReturnBranchOfficeId);
if (returnBranchOffice == null)
{
BadRequest("Non-existent return branch office.");
}
lock (lockObjectForReservations)
{
IEnumerable <Reservation> vehicleReservations = unitOfWork.Reservations.Find(r => r.Id == vehicle.Id);
int numOfexcessiveReservations = vehicleReservations.Where(r => (r.ReservationStart <= model.ReservationStart && r.ReservationEnd >= model.ReservationEnd) || (r.ReservationStart >= model.ReservationStart && r.ReservationEnd <= model.ReservationEnd) || (r.ReservationStart <= model.ReservationStart && r.ReservationEnd <= model.ReservationEnd) || (r.ReservationStart >= model.ReservationStart && r.ReservationEnd >= model.ReservationEnd)).Count();
if (numOfexcessiveReservations > 0)
{
BadRequest("The vehicle was rented in a given period.");
}
RAIdentityUser user = UserManager.FindById(User.Identity.GetUserId());
Reservation reservation = new Reservation()
{
Vehicle = vehicle,
UserId = user.Id,
ReservationStart = model.ReservationStart,
ReservationEnd = model.ReservationEnd,
RentBranchOffice = rentBranchOffice,
ReturnBranchOffice = returnBranchOffice
};
try
{
unitOfWork.Reservations.Add(reservation);
unitOfWork.Complete();
}
catch (DBConcurrencyException)
{
return(NotFound());
}
}
return(Ok("Reservation successfully created."));
}
public async Task MakeReservation_WithCorrectData_ShouldCreateSucessfully(int seats)
{
string errorMessage = "ReservationService MakeReservation() method does not work properly.";
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
this.reservationService = new ReservationService(context);
await SeedData(context);
CreateReservationBindingModel reservationBindingModel = new CreateReservationBindingModel
{
Date = "09/08/2019 20:00:00",
SeatsCount = seats,
Restaurant = "Happy"
};
ReserveTableUserServiceModel user = new ReserveTableUserServiceModel
{
Id = "1",
Email = "*****@*****.**",
UserName = "******"
};
RestaurantServiceModel restaurant = new RestaurantServiceModel
{
Id = "1",
Address = "New Street",
AverageRating = 10,
CityId = "1",
Name = "Happy",
PhoneNumber = "0888888888",
Photo = "/src/happy.jpg",
Tables = new List <TableServiceModel>()
{
new TableServiceModel
{
Id = "1",
SeatsCount = 2,
RestaurantId = "1",
Reservations = new List <ReservationServiceModel>()
}
}
};
var expectedResult = new ReservationServiceModel
{
ForDate = new DateTime(2019, 08, 09, 20, 0, 0),
Restaurant = new RestaurantServiceModel
{
Id = "1",
Address = "New Street",
AverageRating = 10,
CityId = "1",
Name = "Happy",
PhoneNumber = "0888888888",
Photo = "/src/happy.jpg",
Tables = new List <TableServiceModel>()
{
new TableServiceModel
{
Id = "1",
SeatsCount = 2,
RestaurantId = "1",
Reservations = new List <ReservationServiceModel>()
}
}
},
SeatsCount = seats,
UserId = "1"
};
var actualResult = await reservationService.MakeReservation(reservationBindingModel, user, restaurant);
Assert.True(expectedResult.SeatsCount == actualResult.SeatsCount, errorMessage + " " + "Seats Count is not returned properly");
Assert.True(expectedResult.ForDate == actualResult.ForDate, errorMessage + " " + "For Date is not returned properly");
Assert.True(expectedResult.UserId == actualResult.UserId, errorMessage + " " + "User Id is not returned properly");
}
public async Task <ReservationSummary> MakeReservation(CreateReservationBindingModel model)
{
var projection = this.DbContext.Projections.FirstOrDefault(p => p.Id == model.ProjectionId);
if (projection == null)
{
return(new ReservationSummary(false, $"Projection with id {model.ProjectionId} does not exist"));
}
bool isStarted = projection.StartDate < DateTime.UtcNow;
bool isToLate = projection.StartDate < DateTime.UtcNow.AddMinutes(10);
if (isStarted || isToLate)
{
return(new ReservationSummary(false, $"Reservation for this projection are closed"));
}
var room = this.DbContext.Rooms.FirstOrDefault(r => r.Id == projection.RoomId);
bool isValidRow = model.Row > 0 && model.Row <= room.Rows;
bool isValidRColumn = model.Column > 0 && model.Column <= room.SeatsPerRow;
if (!isValidRow || !isValidRColumn)
{
return(new ReservationSummary(false, $"Invalid seat place"));
}
bool isReserved = this.DbContext.Reservations.Where(r => r.ProjectionId == model.ProjectionId)
.FirstOrDefault(r => r.Row == model.Row && r.Column == model.Column)
.Equals(null);
bool isSold = this.DbContext.Tickets.Where(t => t.ProjectionId == model.ProjectionId)
.FirstOrDefault(r => r.Row == model.Row && r.Column == model.Column)
.Equals(null);
if (isReserved || isSold)
{
return(new ReservationSummary(false, $"The place is occupied"));
}
Reservation newReservation = new Reservation();
newReservation.ProjectionId = projection.Id;
newReservation.Row = model.Row;
newReservation.Column = model.Column;
this.DbContext.Reservations.Add(newReservation);
int rowsAffected = await this.DbContext.SaveChangesAsync();
if (rowsAffected == 0)
{
return(new ReservationSummary(false, $"Reservation server error"));
}
var movie = this.DbContext.Movies.First(m => m.Id == projection.MovieId);
var cinema = this.DbContext.Cinemas.First(c => c.Id == room.CinemaId);
ReservationTicket reservationTicket = new ReservationTicket();
reservationTicket.ReservationId = newReservation.Id;
reservationTicket.StartDate = projection.StartDate;
reservationTicket.MovieName = movie.Name;
reservationTicket.CinemaName = cinema.Name;
reservationTicket.RoomNumber = room.Number;
reservationTicket.Row = newReservation.Row;
reservationTicket.Column = newReservation.Column;
return(new ReservationSummary(true, reservationTicket));
}
