public async Task <IActionResult> Edit(ReservationsEditViewModel editModel)
{
if (ModelState.IsValid)
{
Reservation reservation = new Reservation()
{
FirstName = editModel.FirstName,
SecondName = editModel.SecondName,
LastName = editModel.LastName,
EGN = editModel.EGN,
PhoneNumber = editModel.PhoneNumber,
Nationality = editModel.Nationality,
TypeOfTicket = editModel.TypeOfTicket,
Email = editModel.Email
};
try
{
_context.Update(reservation);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ReservationExists(reservation.EGN))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(editModel));
}
public IActionResult Edit(int?id)
{
if (GlobalVar.LoggedOnUserId == -1)
{
return(RedirectToAction("LogInRequired", "Users"));
}
if (id == null || !ReservationExists((int)id))
{
return(NotFound());
}
Reservation reservation = _context.Reservations.Find(id);
ReservationsEditViewModel model = new ReservationsEditViewModel()
{
Id = reservation.Id,
DateOfAccommodation = reservation.DateOfAccommodation,
DateOfExemption = reservation.DateOfExemption,
IsAllInclusive = reservation.IsAllInclusive,
IsBreakfastIncluded = reservation.IsBreakfastIncluded,
OverallBill = reservation.OverallBill
};
return(View(model));
}
// GET: Reservations/Edit/id
public async Task <IActionResult> Edit(int?id)
{
if (GetCookie("LoggedIn") != "true")
{
return(Redirect("/"));
}
else
{
if (id == null)
{
return(NotFound());
}
Reservation reservation = await _context.Reservations.FindAsync(id);
if (reservation == null)
{
return(NotFound());
}
ReservationsEditViewModel model = new ReservationsEditViewModel();
model.RoomNumber = reservation.RoomNumber;
model.UserId = reservation.UserId;
model.ClientsIds = reservation.ClientsIds.Split(",", StringSplitOptions.RemoveEmptyEntries).Select(i => int.Parse(i)).ToArray();
model.DateAccomodation = reservation.DateAccomodation;
model.DateRelease = reservation.DateRelease;
model.BreakfastIncluded = reservation.BreakfastIncluded;
model.AllInclusive = reservation.AllInclusive;
model.PaymentAmount = reservation.PaymentAmount;
return(View(GenerateReservationEditViewModel(model)));
}
}
//GET: Reservation/Edit
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
Reservation reservation = await _context.Reservations.FindAsync(id);
if (reservation == null)
{
return(NotFound());
}
ReservationsEditViewModel model = new ReservationsEditViewModel
{
FirstName = reservation.FirstName,
SecondName = reservation.SecondName,
LastName = reservation.LastName,
EGN = reservation.EGN,
PhoneNumber = reservation.PhoneNumber,
Nationality = reservation.Nationality,
TypeOfTicket = reservation.TypeOfTicket,
Email = reservation.Email
};
return(View(model));
}
public IActionResult Edit(ReservationsEditViewModel editModel)
{
if (GlobalVar.LoggedOnUserId == -1)
{
return(RedirectToAction("LogInRequired", "Users"));
}
if (!ReservationExists(editModel.Id))
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
Validate(new Validation_Reservation()
{
DateOfAccommodation = editModel.DateOfAccommodation,
DateOfExemption = editModel.DateOfExemption,
RoomId = _context.Reservations.Find(editModel.Id).RoomId,
ReservationId = editModel.Id
});
}
catch (InvalidOperationException e)
{
editModel.Message = e.Message;
return(View(editModel));
}
Reservation reservation = _context.Reservations.Find(editModel.Id);
reservation.DateOfAccommodation = editModel.DateOfAccommodation;
reservation.DateOfExemption = editModel.DateOfExemption;
reservation.IsAllInclusive = editModel.IsAllInclusive;
reservation.IsBreakfastIncluded = editModel.IsBreakfastIncluded;
_context.Reservations.Update(reservation);
_context.SaveChanges();
reservation.OverallBill = CalculateOverAllPrice(reservation.Id);
_context.Reservations.Update(reservation);
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
return(View(editModel));
}
public async Task <IActionResult> Edit(string?id)
{
if (id == null)
{
return(NotFound());
}
Reservation reservation = await _context.Reservations
.Include(room => room.Room)
.Include(user => user.User)
.SingleOrDefaultAsync(rese => rese.Id == id);
if (reservation == null)
{
return(NotFound());
}
List <ReservationCreateRoomViewModel> rooms = _context.Rooms.Select(x => new ReservationCreateRoomViewModel(x.Id, x.number, x.type, x.PriceForAdult, x.PriceForKid, x.IsFree)).ToList();
List <ReservationCreateRoomViewModel> freeRooms = new List <ReservationCreateRoomViewModel>();
freeRooms.Add(new ReservationCreateRoomViewModel(reservation.Room.Id, reservation.Room.number, reservation.Room.type, reservation.Room.PriceForAdult, reservation.Room.PriceForKid, reservation.Room.IsFree));
foreach (var room in rooms)
{
if (room.IsFree)
{
freeRooms.Add(room);
}
}
ReservationsEditViewModel model = new ReservationsEditViewModel
{
Id = reservation.Id,
User = reservation.User,
Room = reservation.Room,
AccommodationDate = reservation.AccommodationDate,
ReleaseDate = reservation.ReleaseDate,
HaveBreakFast = reservation.HaveBreakFast,
IsAllInclusive = reservation.IsAllInclusive
};
model.RoomsAdded = freeRooms;
Room r = await _context.Rooms.SingleOrDefaultAsync(x => x.Id == reservation.Room.Id);
r.IsFree = true;
_context.Update(r);
await _context.SaveChangesAsync();
return(View(model));
}
public ActionResult Edit(ReservationsEditViewModel vm)
{
if (!IsUserSignedIn())
{
return(RedirectToAction("SignIn", "Account"));
}
if (!ModelState.IsValid)
{
return(Content("Coś poszło nie tak.."));
}
_reservationService.Update(vm.ReservationId, vm.Date, vm.Difficulty, GetSignedInUsername());
return(View("ReservationEdited"));
}
private ReservationsEditViewModel GenerateReservationEditViewModel(ReservationsEditViewModel model = null)
{
if (model == null)
{
model = new ReservationsEditViewModel();
}
model.AllAvailableRooms = _context.Rooms.ToArray().Select(r => r.Number).ToArray();
model.AllUsersNames = _context.Users.ToArray().Select(user => user.FirstName + " " + user.LastName).ToArray();
model.AllUsersIds = _context.Users.ToArray().Select(user => user.Id).ToArray();
model.AllClientsNames = _context.Clients.ToArray().Select(client => client.FirstName + " " + client.LastName).ToArray();
model.AllClientsIds = _context.Clients.ToArray().Select(client => client.Id).ToArray();
return(model);
}
public async Task <IActionResult> Edit(ReservationsEditViewModel model)
{
if (GetCookie("LoggedIn") != "true")
{
return(Redirect("/"));
}
else
{
if (ModelState.IsValid)
{
Reservation reservation = new Reservation();
reservation.RoomNumber = model.RoomNumber;
reservation.UserId = model.UserId;
reservation.ClientsIds = string.Join(",", model.ClientsIds);
reservation.DateAccomodation = model.DateAccomodation;
reservation.DateRelease = model.DateRelease;
reservation.BreakfastIncluded = model.BreakfastIncluded;
reservation.AllInclusive = model.AllInclusive;
if (reservation.DateAccomodation.CompareTo(reservation.DateRelease) >= 0)
{
ModelState.AddModelError("DateRelease", "The release date cannot be before the date of аccomodation");
return(View(GenerateReservationEditViewModel(model)));
}
Room room = _context.Rooms.ToArray().Where(r => r.Number == reservation.RoomNumber).FirstOrDefault();
int nAdult = _context.Clients.ToArray().Where(c => model.ClientsIds.Contains(c.Id) && c.Adult).ToArray().Length;
int nChild = _context.Clients.ToArray().Where(c => model.ClientsIds.Contains(c.Id) && !c.Adult).ToArray().Length;
reservation.PaymentAmount = CalculatePaymentAmount(nAdult, nChild, (reservation.DateRelease - reservation.DateAccomodation).Days, room.BedPriceAdult, room.BedPriceChild, reservation.AllInclusive, reservation.BreakfastIncluded);
try
{
_context.Reservations.Update(reservation);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(NotFound());
}
return(RedirectToAction(nameof(Index)));
}
return(View(GenerateReservationEditViewModel(model)));
}
}
public ActionResult Edit(int?id)
{
ReservationRepository repository = new ReservationRepository();
ReservationsEditViewModel model = new ReservationsEditViewModel();
if (id.HasValue)
{
Reservation reservation = repository.GetByID(id.Value);
model.ID = reservation.ID;
model.Users = PopulateUsersList();
model.Restaurants = PopulateRestaurantsList();
model.PeopleCount = model.PeopleCount;
model.ReservationTime = model.ReservationTime.Date;
model.Comment = model.Comment;
}
return(View(model));
}
public ActionResult Edit(int Id)
{
ReservationsRepository repo = new ReservationsRepository();
Reservation dbreservation = new Reservation();
dbreservation = repo.Get(Id);
ReservationsEditViewModel model = new ReservationsEditViewModel();
model.PeopleCount = dbreservation.PeopleCount;
model.ReservationTime = dbreservation.ReservationTime;
model.Comment = dbreservation.Comment;
model.UserId = dbreservation.UserId;
model.ResraurantId = dbreservation.RestaurantId;
model.Id = Id;
UsersRepository rep = new UsersRepository();
ViewBag.UserId = new SelectList(rep.GetAll(), "Id", "Name");
RestaurantsRepository repository = new RestaurantsRepository();
ViewBag.RestaurantId = new SelectList(repository.GetAll(), "Id", "Name");
return(View(model));
}
public async Task <IActionResult> Edit(ReservationsEditViewModel model)
{
if (GetCookie("LoggedIn") != "true")
{
return(Redirect("/"));
}
else
{
if (ModelState.IsValid)
{
Reservation reservation = new Reservation
{
RoomNumber = model.RoomNumber,
UserId = model.UserId,
ClientsIds = string.Join(",", model.ClientsIds),
DateAccomodation = model.DateAccomodation,
DateRelease = model.DateRelease,
BreakfastIncluded = model.BreakfastIncluded,
AllInclusive = model.AllInclusive,
PaymentAmount = model.PaymentAmount
};
try
{
_context.Reservations.Update(reservation);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(NotFound());
}
return(RedirectToAction(nameof(Index)));
}
return(View(GenerateReservationEditViewModel(model)));
}
}
public ActionResult Edit(ReservationsEditViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
ReservationRepository repository = new ReservationRepository();
Reservation reservation = new Reservation();
reservation.ID = model.ID;
reservation.UserId = model.UserId;
reservation.RestaurantId = model.RestaurantId;
reservation.PeopleCount = model.PeopleCount;
reservation.ReservationTime = model.ReservationTime;
reservation.Comment = model.Comment;
repository.Save(reservation);
return(RedirectToAction("Index"));
}
public ActionResult Edit(ReservationsEditViewModel model)
{
if (!ModelState.IsValid)
{
UsersRepository rep = new UsersRepository();
ViewBag.UserId = new SelectList(rep.GetAll(), "Id", "Name");
RestaurantsRepository repos = new RestaurantsRepository();
ViewBag.RestaurantId = new SelectList(repos.GetAll(), "Id", "Name");
return(View());
}
Reservation reservation = new Reservation();
reservation.Id = model.Id;
reservation.PeopleCount = model.PeopleCount;
reservation.ReservationTime = model.ReservationTime;
reservation.Comment = model.Comment;
reservation.UserId = model.UserId;
reservation.RestaurantId = model.ResraurantId;
ReservationsRepository repo = new ReservationsRepository();
repo.Update(reservation);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Edit(ReservationsEditViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
User user = _context.Users.FirstOrDefault(x => x.Id == userId);
Room room = _context.Rooms.FirstOrDefault(x => x.Id == model.RoomId);
room.IsFree = false;
decimal adults = 0, kids = 0;
List <Client> clients = new List <Client>();
Reservation reser = await this._context.Reservations
.Include(res => res.Clients)
.ThenInclude(client => client.Client)
.SingleOrDefaultAsync(rese => rese.Id == model.Id);
List <ClientReservation> cl = _context.ClientReservations.Where(res => res.Reservation.Id == reser.Id).ToList();
List <string> clId = new List <string>();
foreach (var c in cl)
{
clId.Add(c.Client.Id);
}
foreach (var c in clId)
{
Client client = new Client();
client = _context.Clients.FirstOrDefault(x => x.Id == c);
clients.Add(client);
}
foreach (var client in clients)
{
if (client.IsAdult)
{
adults++;
}
else
{
kids++;
}
}
var days = (decimal)(model.ReleaseDate.Subtract(model.AccommodationDate.Date).TotalDays);
decimal dueAm = days * (adults * room.PriceForAdult + kids * room.PriceForKid);
reser.Id = model.Id;
reser.User = user;
reser.Room = room;
reser.AccommodationDate = model.AccommodationDate;
reser.ReleaseDate = model.ReleaseDate;
reser.HaveBreakFast = model.HaveBreakFast;
reser.IsAllInclusive = model.IsAllInclusive;
reser.DueAmount = dueAm;
_context.Update(reser);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(All)));
}
