public async Task <IActionResult> Reserve(RestaurantInputModel input)
{
var remainingCapacity = this.restaurantService.GetRemainingCapacity();
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
var userId = await this.usersService.GetUserIdAsync(this.User);
input.UserId = userId;
var result = await this.restaurantService.ReserveRestaurant(input);
if (result == false)
{
this.ModelState.AddModelError("EventDate", GlobalConstants.FreeSeatsForRestaurantError + remainingCapacity);
return(this.View(input));
}
this.TempData["InfoMessage"] = GlobalConstants.ReserveRestaurantTempDataSuccess;
return(this.Redirect("/Restaurant/Reservations"));
}
public async Task <bool> ReserveRestaurant(RestaurantInputModel input)
{
var restaurant = this.restaurantRepository.All().FirstOrDefault(x => x.IsDeleted == false);
if (restaurant != null && input.NumberOfGuests <= restaurant.MaxCapacity && input.EventDate.Day >= DateTime.Now.Day)
{
var restaurantReservation = new RestaurantReservation()
{
UserId = input.UserId,
RestaurantId = restaurant.Id,
NumberOfGuests = input.NumberOfGuests,
PhoneNumber = input.PhoneNumber,
EventType = input.EventType,
EventDate = input.EventDate,
CheckIn = input.CheckIn,
CheckOut = input.CheckOut,
TotalPrice = 0,
Message = input.Message,
};
var totalHours = (decimal)(restaurantReservation.CheckIn - restaurantReservation.CheckOut).TotalHours;
var price = Math.Abs(restaurant.Price * totalHours);
restaurantReservation.TotalPrice = price;
var allReservationsForDate = this.restaurantReservationRepository.All().Where(x => x.EventDate == input.EventDate);
var allReservations = this.restaurantReservationRepository.All().Select(x => x.EventDate).ToList();
if (allReservationsForDate.Count() != 0)
{
foreach (var item in allReservationsForDate)
{
if (restaurantReservation.NumberOfGuests > restaurant.CurrentCapacity)
{
return(false);
}
}
}
if (allReservations.Contains(input.EventDate))
{
restaurant.CurrentCapacity -= input.NumberOfGuests;
}
else
{
restaurant.CurrentCapacity = restaurant.MaxCapacity;
restaurant.CurrentCapacity -= input.NumberOfGuests;
}
await this.restaurantReservationRepository.AddAsync(restaurantReservation);
await this.restaurantReservationRepository.SaveChangesAsync();
return(true);
}
throw new InvalidOperationException(GlobalConstants.InvalidOperationExceptionForRestaurantReservation);
}
public RestaurantDetailViewModel Insert(RestaurantInputModel inputModel)
{
var restaurant = new Restaurant(inputModel.Name);
restaurant = _restaurantService.Insert(restaurant);
return(GetDetailViewModel(restaurant));
}
public void ConvertFromAddInputModel(RestaurantInputModel r)
{
Naam = r.Naam;
Omschrijving = r.Omschrijving;
Telefoon = r.Telefoon;
Email = r.Email;
Website = r.Website;
}
public async Task <IActionResult> Reserve()
{
var inputModel = new RestaurantInputModel
{
PhoneNumber = await this.usersService.GetUserPhoneNumberAsync(this.User),
EventDate = DateTime.Now,
};
return(this.View(inputModel));
}
public IActionResult Put([FromBody] RestaurantInputModel inputModel)
{
try
{
return(ResponseOk(_restaurantAppService.Update(inputModel)));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IActionResult Post([FromBody] RestaurantInputModel inputModel)
{
try
{
return(ResponseOk(_restaurantAppService.Insert(inputModel)));
}
catch (Exception ex)
{
return(BadRequest(new ErrorResponse(ex.Message, HttpStatusCode.BadRequest)));
}
}
public ActionResult EditRestaurant(RestaurantInputModel restaurant)
{
if (ModelState.IsValid)
{
Restaurant rstToEdit = db.GetRestaurant(restaurant.RestaurantID);
rstToEdit.ConvertFromRestaurantInputModel(restaurant); //Make restaurant from input model
db.UpdateRestaurant(rstToEdit);
}
else
{
ModelState.AddModelError("edit-error", "The Restaurant you tried to edit had some incorrectly filled fields.");
}
return(View(restaurant));
}
public ActionResult EditRestaurant(int?id)
{
//Get Restaurant
if (id != null)
{
Restaurant restaurant = db.GetRestaurant(id.Value);
if (restaurant != null)
{
RestaurantInputModel rst = new RestaurantInputModel();
rst.ConvertToRestaurantInputModel(restaurant);
return(View(rst));
}
}
return(RedirectToAction("ManagementWindow"));
}
//public void Edit(Restaurant r)
//{
// Naam = r.Naam;
// Omschrijving = r.Omschrijving;
// Telefoon = r.Telefoon;
// Email = r.Email;
// Website = r.Website;
// RestaurantAfbeelding.Link = r.RestaurantAfbeelding.Link;
// RestaurantLocatie.Straat = r.RestaurantLocatie.Straat;
// RestaurantLocatie.Huisnummer = r.RestaurantLocatie.Huisnummer;
// RestaurantLocatie.Toevoeging = r.RestaurantLocatie.Toevoeging;
// RestaurantLocatie.Postcode = r.RestaurantLocatie.Postcode;
//}
public void ConvertFromRestaurantInputModel(RestaurantInputModel r)
{
Naam = r.Naam;
Omschrijving = r.Omschrijving;
Telefoon = r.Telefoon;
Email = r.Email;
Website = r.Website;
RestaurantAfbeelding.Link = r.RestaurantAfbeelding.Link;
OverviewAfbeelding.Link = r.OverviewAfbeelding.Link;
RestaurantLocatie = r.RestaurantLocatie;
//RestaurantLocatie.Straat = r.RestaurantLocatie.Straat;
//RestaurantLocatie.Huisnummer = r.RestaurantLocatie.Huisnummer;
//RestaurantLocatie.Toevoeging = r.RestaurantLocatie.Toevoeging;
//RestaurantLocatie.Postcode = r.RestaurantLocatie.Postcode;
}
public async Task Reserve_Restaurant_Should_Reserve_For_Choosen_Guests()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
this.dbContext = new ApplicationDbContext(options);
var restaurantRepository = new EfDeletableEntityRepository <Restaurant>(this.dbContext);
var restaurantReservationRepository = new EfDeletableEntityRepository <RestaurantReservation>(this.dbContext);
await restaurantRepository.AddAsync(new Restaurant
{
Id = "restaurantid",
CurrentCapacity = 100,
MaxCapacity = 100,
Description = "restaurant",
Price = 50,
Title = "restaurant",
});
await restaurantRepository.SaveChangesAsync();
this.restaurantsService = new RestaurantsService(restaurantRepository, restaurantReservationRepository);
var reservation = new RestaurantInputModel
{
EventDate = DateTime.Now.AddDays(1),
CheckIn = DateTime.Now.AddDays(1).AddHours(10),
CheckOut = DateTime.Now.AddDays(1).AddHours(11),
NumberOfGuests = 50,
EmailAddress = "*****@*****.**",
FirstName = "Marian",
LastName = "Kyuchukov",
PhoneNumber = "0888186978",
EventType = (RestaurantEventType)Enum.Parse(typeof(RestaurantEventType), "Birthday"),
};
var result = await this.restaurantsService.ReserveRestaurant(reservation);
var parsedEventType = (RestaurantEventType)Enum.Parse(typeof(RestaurantEventType), "Birthday");
var actualResult = restaurantReservationRepository.All().FirstOrDefault(x => x.EventType == parsedEventType).NumberOfGuests;
var expected = 50;
Assert.Equal(expected, actualResult);
}
public ActionResult AddRestaurant(RestaurantInputModel r, string afbLink, string afbLinkOverview)
{
if (ModelState.IsValid)
{
Restaurant rst = new Restaurant();
rst.ConvertFromAddInputModel(r); //Maken van een Restaurant van input model
r.RestaurantLocatie.Naam = r.Naam;
rst.RestaurantAfbeelding = new Afbeelding(null, null, rst.RestaurantID, afbLink, "restaurantbanner");
rst.OverviewAfbeelding = new Afbeelding(null, null, rst.RestaurantID, afbLinkOverview, "restaurantoverview");
rst.RestaurantLocatie = r.RestaurantLocatie;
db.AddRestaurant(rst);
return(RedirectToAction("ManagementWindow"));
}
return(View(r));
}
public RestaurantDetailViewModel Update(RestaurantInputModel inputModel)
{
if (!inputModel.Id.HasValue)
{
throw new Exception("Id não enviado.");
}
var restaurant = _restaurantService.GetById((long)inputModel.Id);
if (restaurant == null)
{
throw new Exception("Restaurante não encontrado.");
}
restaurant.Update(inputModel.Name);
restaurant = _restaurantService.Update(restaurant);
return(GetDetailViewModel(restaurant));
}
public IActionResult Save(RestaurantInputModel model)
{
this.service.Save(model);
return(this.Ok());
}
