public ActionResult SubmitRequest(ReservationRequestModel model)
{
ViewBag.IsReturning = true;
CheckDates(model.ArrivalDate, model.DepartureDate);
// if(model.NumberOfPersons > )
if (!ModelState.IsValid)
{
//Perhaps you might want to add a custom message to the ViewBag
//which will be available on the View when it renders (since we're not
//redirecting)
TempData["ErrorMessage"] = "Popraw błędy i spróbuj ponownie przesłać formularz.";
return(CurrentUmbracoPage());
}
if (CheckReservationTermAlreadyBooked(model.ApartmentName, ParseDate(model.ArrivalDate), ParseDate(model.DepartureDate)))
{
TempData["ErrorMessage"] =
"Wybrane mieszkanie jest niestety zajęte w podanym czasie. Proszę wybrać inny termin.";
return(CurrentUmbracoPage());
}
var reservationResult = AddReservation(model);
SendEmail(model, reservationResult ? string.Empty : "Otrzymano nowy wniosek o rezerwację jednak z powodu błędu nie został on zapisany:");
//Add a message in TempData which will be available
//in the View after the redirect
TempData["SuccessMessage"] = "Twój wniosek o rezerwację został poprawnie zarejestrowany. Prosimy o oczekiwanie na kontakt.";
//redirect to current page to clear the form
var url = Umbraco.Url(CurrentPage.Id);
return(Redirect($"{url}#reservation"));
}
public IActionResult ToBook([FromBody] ReservationRequestModel reservation)
{
//_context.SaveChanges();
//var user = _context.GetUserFromToken(User);
//var session = _context.Sessions.Where(x => x.Id == reservation.SessionId).FirstOrDefault();
//var seat = session.CinemaHall.Seats.Where(x => x.Number == reservation.Number && x.Row == reservation.Row).FirstOrDefault();
//if (session.IsBusySeat(seat.Id))
//{
// return BadRequest("place already taken");
//}
//Reservation saveReserv = new Reservation
//{
// SeatId = seat.Id,
// SessionId = session.Id,
// UserId = user.Id,
// Paid = false
//};
//_context.Reservations.Add(saveReserv);
return(Ok());
}
private string CreateMailBody(ReservationRequestModel model)
{
var price = GetTotalPriceInner(model.ApartmentName, model.ArrivalDate, model.DepartureDate, model.NumberOfPersons);
return($@"Nazwa apartamentu: <b>{model.ApartmentName}</b><br>
Cena całkowita: <b>{price.TotalPrice} PLN</b><br>
Data przyjazdu: <b>{model.ArrivalDate} godz. 14:00</b><br>
Data wyjazdu: <b>{model.DepartureDate} godz. 12:00</b><br>
Liczba nocy: <b>{price.TotalNights}</b><br>
Ilość osób: <b>{model.NumberOfPersons}</b><br>
Dodatkowe informacje: <b>{model.Comments}</b><br>
<br>
Imię: <b>{model.FirstName}</b><br>
Nazwisko: <b>{model.LastName}</b><br>
Ulica: <b>{model.Street}</b><br>
Kod pocztowy: <b>{model.Zip}</b><br>
Miasto: <b>{model.City}</b><br>
Kraj: <b>{model.Country}</b><br>
Telefon: <b>{model.Phone}</b><br>
Email: <b>{model.Email}</b>");
// return string.Join(Environment.NewLine,
// model.GetType()
// ?.GetProperties()
// ?.Where(p => p.GetCustomAttribute<SkipInEmailAttribute>() == null)
// ?.Select(
// p =>
// $"{p.GetCustomAttribute<DisplayAttribute>()?.Name ?? string.Empty}: <b>{p.GetValue(model)?.ToString() ?? string.Empty}</b>") ?? new string[0]);
}
private void SendEmail(ReservationRequestModel model, string additionalMessage = "")
{
var smtpClient = new SmtpClient
{
Host = "smtp.gmail.com",
Port = 587,
EnableSsl = true,
DeliveryMethod = SmtpDeliveryMethod.Network,
UseDefaultCredentials = false,
Credentials = new NetworkCredential("*****@*****.**", "kingsofmetal8008")
};
var adminEmail =
Umbraco.TypedContentAtRoot()
.First(c => c.DocumentTypeAlias == "Rezerwacje")
.GetPropertyValue <string>("email");
var message = new MailMessage("*****@*****.**", adminEmail)
{
Body = $"{additionalMessage}{Environment.NewLine}{CreateMailBody(model)}",
Subject = $"Rezerwacja - {model.FirstName} {model.LastName}, {model.ArrivalDate}-{model.DepartureDate}, {model.ApartmentName}",
BodyEncoding = Encoding.UTF8,
SubjectEncoding = Encoding.UTF8,
IsBodyHtml = true
};
smtpClient.Send(message);
}
public ReservationDetailedModel AddReservation(ReservationRequestModel reservationRequest)
{
if (reservationRequest.TableIds?.Count > 0)
{
ValidateReservationRequest(reservationRequest);
var areTablesAvailable = _availabilityService.AreTablesAvailable(reservationRequest.TableIds, reservationRequest.Range);
if (!areTablesAvailable)
{
throw new ReservationNotAvailableException();
}
}
else
{
var mostFitTableId = GetMostFitTableId(reservationRequest);
reservationRequest.TableIds = new List <int> {
mostFitTableId
};
}
var reservation = _mapper.Map <Reservation>(reservationRequest);
_dbContext.Reservations.Add(reservation);
_dbContext.SaveChanges();
_dbContext.Entry(reservation).Reference(p => p.Restaurant).Load();
_dbContext.Entry(reservation).Reference(p => p.User).Load();
_dbContext.Entry(reservation).Collection(p => p.ReservedTables)
.Query().Include(rt => rt.Table).Load();
return(_mapper.Map <ReservationDetailedModel>(reservation));
}
public ReservationDetailedModel UpdateReservation(ReservationRequestModel reservationRequest)
{
var reservation = _dbContext.Reservations
.Include(r => r.ReservedTables)
.Include(r => r.Restaurant)
.Include(r => r.User)
.FirstOrDefault(r => r.Id == reservationRequest.Id);
reservation = reservation ?? throw new ReservationNotFoundException();
// override properties that are not changeable
reservationRequest.UserId = reservation.UserId;
reservationRequest.RestaurantId = reservation.RestaurantId;
ValidateReservationRequest(reservationRequest);
// check if the newly added tables are available
var oldTableIds = reservation.ReservedTables
.Select(rt => rt.RestaurantTableId).ToList();
var updatedTableIds = reservationRequest.TableIds;
var oldTableReservations = reservation.ReservedTables.Select(rt => rt.Id).ToList();
var areTablesAvailable = _availabilityService.AreTablesAvailable(updatedTableIds, reservationRequest.Range, oldTableReservations);
if (!areTablesAvailable)
{
throw new ReservationNotAvailableException();
}
reservation = _mapper.Map(reservationRequest, reservation);
_dbContext.SaveChanges();
return(_mapper.Map <ReservationDetailedModel>(reservation));
}
public IActionResult AddReservation([FromBody] ReservationRequestModel request)
{
var obj = _inventorReservationService.AddReservation(request);
var tempReserv = _context.Inventorius.Where(x => x.Id == request.Inventoriusid).FirstOrDefault();
int amount = (int)(tempReserv.KiekisLaisvu);
tempReserv.KiekisLaisvu = amount - 1;
_context.SaveChanges();
return(Ok());
}
//todo Add functionality for multiple tables. The returning type should be an array of tableIds that will be assigned to the reservation
//todo Catch exception when there are no available tables
private int GetMostFitTableId(ReservationRequestModel reservationRequest)
{
var availableTables = _availabilityService.GetAvailableTables(reservationRequest.RestaurantId,
reservationRequest.Range,
reservationRequest.ParticipantsCount ?? 0);
var minimumTableSeatsAvailable = availableTables.Min(t => t.Seats);
var mostFittingTable = availableTables.FirstOrDefault(t => t.Seats == minimumTableSeatsAvailable);
return(mostFittingTable.Id);
}
public bool MakeReservation(ReservationRequestModel reservationRequest)
{
foreach (OffreModel offre in db.Offres)
{
if (offre.Id == reservationRequest.OffreId)
{
offre.Chambre.Reservation.Add(reservationRequest.Reservation);
return(true);
}
}
return(false);
}
public InventoriausRezervacijos AddReservation(ReservationRequestModel request)
{
int tempDarbuotojoID = _context.Darbuotojai.Where(x => x.FkProfiliaiid == request.ProfilioID).FirstOrDefault().IdDarbuotojai;
InventoriausRezervacijos addThis = new InventoriausRezervacijos
{
Data = request.Data,
LaikasNuo = request.LaikasNuo,
LaikasIki = request.LaikasIki,
FkDarbuotojaiidDarbuotojai = tempDarbuotojoID,
FkInventoriusid = request.Inventoriusid
};
_context.InventoriausRezervacijos.Add(addThis);
_context.SaveChanges();
return(addThis);
}
public IHttpActionResult Index(ReservationRequestModel model)
{
NewReservationSummery summery = newReserv.New(new Reservation(
model.ProjectionId,
model.Row,
model.Column
));
if (summery.IsCreated)
{
return(Ok(summery.ReservationTicket));
}
else
{
return(BadRequest(summery.Message));
}
}
public IActionResult Put(int id, [FromBody] ReservationRequestModel reservationRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
reservationRequest.Id = id;
try
{
var reservation = _reservationsService.UpdateReservation(reservationRequest);
return(Ok(reservation));
}
catch (ReservationNotFoundException)
{
return(NotFound());
}
}
private void ValidateReservationRequest(ReservationRequestModel reservationRequest)
{
if (reservationRequest.TableIds == null || reservationRequest.TableIds.Count == 0)
{
// no tables were selected
throw new TableNotFoundException();
}
reservationRequest.TableIds = reservationRequest.TableIds.Distinct().ToList();
var tablesFromDb = _dbContext.RestaurantTables
.Include(t => t.Map)
.Where(t => reservationRequest.TableIds.Contains(t.Id))
.Where(t => t.Map.RestaurantId == reservationRequest.RestaurantId)
.ToList();
// check that all the tables are present in the DB
// check that the tables are belonging to this restaurant
if (reservationRequest.TableIds.Count != tablesFromDb.Count)
{
throw new TableNotFoundException();
}
// check if the number of participants could fit the table's seats
var availableSeatsCount = tablesFromDb.Select(t => t.Seats).Sum();
var areTablesFittingTheNumberOfParticipants = availableSeatsCount >= reservationRequest.ParticipantsCount;
if (!areTablesFittingTheNumberOfParticipants)
{
throw new TablesAreNotFittingException();
}
// check if the table assignation is optimal (if there could be less tables requested)
var areTooManyTablesRequested =
_availabilityService.AreTooManyTablesRequested(tablesFromDb, reservationRequest.ParticipantsCount ?? 0);
if (areTooManyTablesRequested)
{
throw new TooManyTablesRequestedException();
}
}
public IActionResult Post([FromRoute] int restaurantId, [FromBody] ReservationRequestModel reservationRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdClaim = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
if (!int.TryParse(userIdClaim, out var userId))
{
throw new InvalidClaimException();
}
reservationRequest.UserId = userId;
reservationRequest.RestaurantId = restaurantId;
var reservation = _reservationsService.AddReservation(reservationRequest);
return(Ok(reservation));
}
public bool MakeReservation([FromBody] ReservationRequestModel reservationRequest)
{
// --- Création d'un client Rest
var client = new RestClient(APIUrl);
// --- Mise en place de la requête
var request = new RestRequest(reservationRequest.AgenceName + "/Reservation", Method.POST);
request.AddJsonBody(reservationRequest);
request.AddHeader("Content-Type", "application/json; charset=utf-8");
// --- Exécution et gestion de la réponse
var response = client.Execute(request);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return(JsonConvert.DeserializeObject <bool>(response.Content));
}
return(false);
}
private bool AddReservation(ReservationRequestModel model)
{
var reservationsNode = Umbraco.TypedContentAtRoot().First(c => c.DocumentTypeAlias == "Rezerwacje");
var dt = Services.ContentTypeService.GetContentType("Rezerwacja");
var doc = new Content($"{model.FirstName} {model.LastName}", reservationsNode.Id, dt);
doc.SetPropertyValue("imie", model.FirstName);
doc.SetPropertyValue("nazwisko", model.LastName);
doc.SetPropertyValue("email", model.Email);
doc.SetPropertyValue("apartament", model.ApartmentName);
doc.SetPropertyValue("dataPrzyjazdu", ParseDate(model.ArrivalDate));
doc.SetPropertyValue("dataWyjazdu", ParseDate(model.DepartureDate));
doc.SetPropertyValue("iloscOsob", model.NumberOfPersons);
doc.SetPropertyValue("dodatkoweInformacje", model.Comments);
doc.SetPropertyValue("ulica", model.Street);
doc.SetPropertyValue("kodPocztowy", model.Zip);
doc.SetPropertyValue("miasto", model.City);
doc.SetPropertyValue("kraj", model.Country);
doc.SetPropertyValue("telefon", model.Phone);
SetReservationStatus(doc, "oczekująca");
var status = Services.ContentService.SaveAndPublishWithStatus(doc);
return(status.Success);
}
