// GET: Reservation/Edit/5
public async Task <IActionResult> Edit(string id)
{
if (id == null)
{
return(NotFound());
}
var reservation = await _context.Reservations.FirstOrDefaultAsync();
if (reservation == null)
{
return(NotFound());
}
await _context.UpdateRooms();
var reservationVM = new EditReservationViewModel
{
AllInclusive = reservation.AllInclusive,
Breakfast = reservation.Breakfast,
CheckInTime = reservation.CheckInTime,
CheckOutTime = reservation.CheckOutTime,
ClientIds = reservation.ClientReservations.Select(x => x.Client.Id).ToList(),
RoomId = reservation.Room.Id,
Id = reservation.Id,
};
reservationVM.AvaiableRooms = await _context.Rooms.OrderBy(x => x.Number).ToListAsync();
reservationVM.AvaiableClients = await _context.Clients.OrderBy(x => x.FirstName).ThenBy(x => x.FirstName).ToListAsync();
return(View(reservationVM));
}
public async Task <bool> EditAsync(EditReservationViewModel reservationEditViewModel)
{
var reservation = this.reservationRepository.All().FirstOrDefault(r => r.Id == reservationEditViewModel.Id);
if (reservation == null)
{
throw new ArgumentNullException(string.Format(string.Format(ServicesDataConstants.InvalidReservationIdErrorMessage, reservationEditViewModel.Id)));
}
if (reservationEditViewModel.UserId == null ||
reservationEditViewModel.StartDate == null ||
reservationEditViewModel.EndDate == null ||
reservationEditViewModel.PaymentTypeId == null ||
reservationEditViewModel.ReservationStatusId == null)
{
throw new ArgumentNullException(string.Format(ServicesDataConstants.InvalidPropertyErrorMessage));
}
reservation.StartDate = reservationEditViewModel.StartDate;
reservation.EndDate = reservationEditViewModel.EndDate;
reservation.Adults = reservationEditViewModel.Adults;
reservation.Kids = reservationEditViewModel.Kids;
reservation.ReservationStatusId = reservationEditViewModel.ReservationStatusId;
reservation.UserId = reservationEditViewModel.UserId;
this.reservationRepository.Update(reservation);
var result = await this.reservationRepository.SaveChangesAsync();
return(result > 0);
}
// GET: Reservations/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Reservation reservation = db.Reservations.Include(r => r.Passenger).SingleOrDefault(x => x.Id == id);
if (reservation == null)
{
return(HttpNotFound());
}
EditReservationViewModel editModel = new EditReservationViewModel()
{
Id = reservation.Id,
RoundTrip = reservation.RoundTrip,
FirstLuggage = reservation.FirstLuggage.Id,
SecondLuggage = reservation.RoundTrip ? reservation.SecondLuggage.Id : -1,
Passenger = reservation.Passenger
};
IEnumerable <SelectListItem> selectListLuggages = from s in db.Luggages.ToList()
select new SelectListItem
{
Value = s.Id.ToString(),
Text = s.ToString()
};
ViewBag.Luggages = new SelectList(selectListLuggages, "Value", "Text");
return(View(editModel));
}
public ActionResult PutReservation(int id, EditReservationViewModel reservation)
{
bool result = _reservationsService.PutReservation(id, reservation);
if (result)
{
return(Ok());
}
return(BadRequest());
}
/// <summary>
/// Change the details on given reservation.
/// </summary>
/// <param name="model"> The updated information about the reservation. </param>
/// <param name="id">The id of the reservation. </param>
/// <returns> The id of the hotel. </returns>
public async Task <string> UpdateAsync(EditReservationViewModel model, string id)
{
var hotelId = id.Split()[0];
var role = id.Split()[1];
var reservationId = id.Split()[2];
var reservation = await this.reservationRepo.GetAsync(reservationId);
if (reservation.Guest.FirstName != model.FirstName && model.FirstName != null)
{
reservation.Guest.FirstName = model.FirstName;
}
if (reservation.Guest.LastName != model.LastName && model.LastName != null)
{
reservation.Guest.LastName = model.LastName;
}
if (reservation.Guest.Email != model.Email && model.Email != null)
{
reservation.Guest.Email = model.Email;
}
if (reservation.Room.RoomNumber != model.RoomNumber && model.RoomNumber != null)
{
reservation.Room = (await this.roomRepo.GetAllAsync()).FirstOrDefault(room => room.RoomNumber == model.RoomNumber);
}
if (reservation.StartDate != model.StartDate && model.StartDate != null)
{
reservation.StartDate = (DateTime)model.StartDate;
}
if (reservation.EndDate != model.EndDate && model.EndDate != null)
{
reservation.EndDate = (DateTime)model.EndDate;
}
if (reservation.Adults != model.Adults && model.Adults != null)
{
reservation.Adults = (int)model.Adults;
}
if (reservation.Children != model.Children && model.Children != null)
{
reservation.Children = (int)model.Children;
}
await this.reservationRepo.SaveChangesAsync();
return(hotelId + " " + role);
}
public ActionResult EditBill(int billId, EditReservationViewModel reservation)
{
var bill = db.Bills.Find(billId);
TimeSpan days = reservation.EndDate - reservation.StartDate;
decimal roomUnitCost = db.Reservations.Find(reservation.ReservationId).Room.UnitCost;
decimal recalculatedTotal = roomUnitCost * reservation.Persons * days.Days;
bill.Total = recalculatedTotal;
db.Entry(bill).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(new EmptyResult());
}
public bool PutReservation(int id, EditReservationViewModel reservation)
{
if (ReservationExists(id))
{
// update in sp the reservation
var test = _context.Database.ExecuteSqlInterpolated($"sp_UpdateReservation {id}, {reservation.ContactId}, {reservation.Description}");
return(true);
}
else
{
return(false);
}
}
public IActionResult Edit(EditReservationViewModel editReservation)
{
bool result = reservationServices.EditReservation(editReservation);
if (!result)
{
return(View(editReservation));
}
else
{
return(Redirect("/"));
}
}
// GET: Reservation/Edit/5
public async Task <IActionResult> Edit(int?id, EditReservationViewModel viewModel)
{
if (id == null)
{
return(View("CustomNotFound"));
}
var reservation = await _context.Reservation.FindAsync(id);
if (reservation == null)
{
return(View("CustomNotFound"));
}
viewModel.Reservation = reservation;
//Location location = await _context.Location.FindAsync(reservation.room.LocationID);
Room room = await _context.Room.FindAsync(reservation.RoomID);
viewModel.SelectedLocation = room.LocationID;
viewModel.SelectedDate = reservation.Date;
viewModel.SelectedRoom = reservation.RoomID;
viewModel.SelectedPeriod = reservation.PeriodID;
List <Location> locations = await _context.Location.ToListAsync();
viewModel.LocationList = new SelectList(locations, "LocationID", "NameAndPlace", room.LocationID);
if (viewModel.SelectedLocation.HasValue)
{
IEnumerable <Room> rooms = _context.Room.ToList()
.Where(x => x.LocationID == viewModel.SelectedLocation.Value);
viewModel.RoomList = new SelectList(rooms, "RoomID", "Description", reservation.RoomID);
}
else
{
viewModel.RoomList = new SelectList(Enumerable.Empty <SelectListItem>());
}
if (viewModel.SelectedRoom.HasValue && viewModel.SelectedDate.HasValue)
{
IEnumerable <Period> hours = await _context.Period.ToListAsync();
viewModel.PeriodList = new SelectList(hours, "PeriodID", "Hour", reservation.PeriodID);
}
else
{
viewModel.PeriodList = new SelectList(Enumerable.Empty <SelectListItem>());
}
return(View(viewModel));
}
public ActionResult EditReservation(int reservationId)
{
var reservation = db.Reservations.Find(reservationId);
var model = new EditReservationViewModel
{
ReservationId = reservationId,
StartDate = reservation.StartDate,
EndDate = reservation.EndDate,
Persons = reservation.Persons
};
return(View(model));
}
public ActionResult Edit(int?id)
{
bool W = false;
bool P = false;
Medication PetResMedication = new Medication();
ViewData["Services"] = _context.Service.Where(p => p.ServiceId != 1).ToList();
ViewData["PetServices"] = _context.PetReservationService
.Where(p => p.PetReservationId == id).ToList();
var petRes = _context.PetReservation
.Include(p => p.Reservation)
.Include(p => p.Pet)
.Include(p => p.Medication)
.Include(p => p.PetReservationService)
.Where(p => p.PetReservationId == id)
.FirstOrDefault();
if (petRes.PetReservationService.Count() > 1)
{
foreach (var serv in petRes.PetReservationService)
{
if (serv.ServiceId == 2)
{
W = true;
}
if (serv.ServiceId == 5)
{
P = true;
}
}
}
if (petRes.Medication.Count() > 0)
{
foreach (var med in petRes.Medication)
{
PetResMedication = med;
}
}
EditReservationViewModel model = new EditReservationViewModel {
PetReservation = petRes, Medication = PetResMedication, Walk = W, PlayTime = P
};
return(View(model));
}
public async Task EditAsync_WithCorrectData_ShouldSuccessfullyEdit()
{
var errorMessagePrefix = "ReservationsService EditAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var reservationRepository = new EfDeletableEntityRepository <Reservation>(context);
var reservationsService = this.GetReservationService(reservationRepository, context);
var seeder = new ReservationsServiceTestsSeeder();
await seeder.SeedReservationAsync(context);
var reservation = context.Reservations.First();
var model = new EditReservationViewModel
{
Id = reservation.Id,
UserId = context.Users.First().Id,
StartDate = new DateTime(2020, 4, 4),
EndDate = new DateTime(2020, 4, 8),
Adults = 2,
Kids = 1,
ReservationStatusId = context.ReservationStatuses.First().Id,
PaymentTypeId = context.PaymentTypes.First().Id,
TotalAmount = 1000,
TotalDays = 4,
AdvancedPayment = 300,
RoomId = context.Rooms.First().Id,
};
// Act
await reservationsService.EditAsync(model);
var actualResult = reservationRepository.All().First();
var expectedResult = model;
// Assert
Assert.True(expectedResult.UserId == actualResult.UserId, errorMessagePrefix + " " + "User is not returned properly.");
Assert.True(expectedResult.StartDate == actualResult.StartDate, errorMessagePrefix + " " + "Start date is not returned properly.");
Assert.True(expectedResult.EndDate == actualResult.EndDate, errorMessagePrefix + " " + "End date is not returned properly.");
Assert.True(expectedResult.Adults == actualResult.Adults, errorMessagePrefix + " " + "Adults is not returned properly.");
Assert.True(expectedResult.Kids == actualResult.Kids, errorMessagePrefix + " " + "Kids is not returned properly.");
Assert.True(expectedResult.TotalAmount == actualResult.TotalAmount, errorMessagePrefix + " " + "Total amount is not returned properly.");
Assert.True(expectedResult.ReservationStatusId == actualResult.ReservationStatusId, errorMessagePrefix + " " + "Reservation status Id is not returned properly.");
Assert.True(expectedResult.AdvancedPayment == actualResult.AdvancedPayment, errorMessagePrefix + " " + "Advanced payment is not returned properly.");
Assert.True(expectedResult.TotalDays == actualResult.TotalDays, errorMessagePrefix + " " + "Total days is not returned properly.");
Assert.True(expectedResult.PaymentTypeId == actualResult.PaymentTypeId, errorMessagePrefix + " " + "Payment type Id is not returned properly.");
Assert.True(expectedResult.ReservationStatusId == actualResult.ReservationStatusId, errorMessagePrefix + " " + "Reservation status is not returned properly.");
}
public async Task <IActionResult> Edit(int id, EditReservationViewModel viewModel)
{
if (id != viewModel.Reservation.ReservationID)
{
return(View("CustomNotFound"));
}
if (ModelState.IsValid)
{
_context.Update(viewModel.Reservation);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(viewModel));
}
public IActionResult Edit(int id)
{
//Room roomForEdit = this.context.Rooms.Find(id);
Reservation reservation = reservationServices.GetReservation(id);
EditReservationViewModel model = new EditReservationViewModel
{
Id = reservation.Id,
ReservedRoom = reservation.ReservedRoom,
ClientReservations = reservation.ClientReservations,
CheckIn = reservation.CheckIn,
CheckOut = reservation.CheckOut,
IncludeBreakfast = reservation.IncludeBreakfast,
AllInclusive = reservation.AllInclusive
};
return(View(model));
}
public ActionResult EditReservation(EditReservationViewModel reservation)
{
var updateReservation = db.Reservations.Find(reservation.ReservationId);
bool modified = false;
if (reservation.Persons != updateReservation.Persons && reservation.Persons <= updateReservation.Room.MaxPeople)
{
updateReservation.Persons = reservation.Persons;
modified = true;
}
if (reservation.StartDate != updateReservation.StartDate)
{
if (updateReservation.StartDate < reservation.StartDate)
{
updateReservation.StartDate = reservation.StartDate;
modified = true;
}
}
if (reservation.EndDate != updateReservation.EndDate)
{
if (updateReservation.EndDate > reservation.EndDate)
{
updateReservation.EndDate = reservation.EndDate;
modified = true;
}
}
if (modified)
{
bool isBillAlreadyCreated = db.Bills.Any(b => b.ReservationId == reservation.ReservationId);
if (isBillAlreadyCreated)
{
int billId = db.Bills.Where(b => b.ReservationId == reservation.ReservationId).Single().BillId;
var controller = DependencyResolver.Current.GetService <BillController>();
var result = controller.EditBill(billId, reservation);
}
db.Entry(updateReservation).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("AllReservations"));
}
return(RedirectToAction("EditReservation", reservation.ReservationId));
}
public bool EditReservation(EditReservationViewModel editReservation)
{
//throw new NotImplementedException();
/*Room room = new Room
* {
* Capacity = editRoom.Capacity,
* RoomType = editRoom.RoomType,
* FreeRoom = editRoom.FreeRoom,
* PricePerAdult = editRoom.PricePerAdult,
* PricePerKid = editRoom.PricePerKid,
* RoomNumber = editRoom.RoomNumber
* };
* this.context.Rooms.Update(room);
* this.context.SaveChanges();
* return true;*/
/*if (editRoom.Capacity<0 ||
* editRoom.RoomType==null ||
* // editRoom.FreeRoom==null ||
* editRoom.PricePerAdult<0 ||
* editRoom.PricePerKid<0)
* {
* return false;
* }*/
Reservation reservation = this.context.Reservations.Find(editReservation.Id);
reservation.ReservedRoom = editReservation.ReservedRoom;
reservation.ClientReservations = editReservation.ClientReservations;
reservation.CheckIn = editReservation.CheckIn;
reservation.CheckOut = editReservation.CheckOut;
reservation.IncludeBreakfast = editReservation.IncludeBreakfast;
reservation.AllInclusive = editReservation.AllInclusive;
this.context.Reservations.Update(reservation);
this.context.SaveChanges();
return(true);
}
public ActionResult Edit([Bind(Include = "Id,RoundTrip,FirstLuggage,SecondLuggage,Passenger")] EditReservationViewModel editReservation)
{
if (ModelState.IsValid)
{
Reservation reservation = db.Reservations.Find(editReservation.Id);
reservation.FirstLuggage = db.Luggages.Find(editReservation.FirstLuggage);
reservation.SecondLuggage = reservation.RoundTrip ? db.Luggages.Find(editReservation.SecondLuggage) : null;
reservation.Passenger = editReservation.Passenger;
db.Entry(reservation).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("MyReservations"));
}
IEnumerable <SelectListItem> selectListLuggages = from s in db.Luggages.ToList()
select new SelectListItem
{
Value = s.Id.ToString(),
Text = s.ToString()
};
ViewBag.Luggages = new SelectList(selectListLuggages, "Value", "Text");
return(View(editReservation));
}
public async Task EditAsync_WithCorrectData_ShouldReturnCorrectResult()
{
var errorMessage = "ReservationsService EditAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var reservationRepository = new EfDeletableEntityRepository <Reservation>(context);
var reservationsService = this.GetReservationService(reservationRepository, context);
var seeder = new ReservationsServiceTestsSeeder();
await seeder.SeedReservationAsync(context);
var reservation = context.Reservations.First();
var model = new EditReservationViewModel
{
Id = reservation.Id,
UserId = context.Users.First().Id,
StartDate = new DateTime(2020, 4, 4),
EndDate = new DateTime(2020, 4, 8),
Adults = 2,
Kids = 1,
ReservationStatusId = context.ReservationStatuses.First().Id,
PaymentTypeId = context.PaymentTypes.First().Id,
TotalAmount = 1000,
TotalDays = 4,
AdvancedPayment = 300,
RoomId = context.Rooms.First().Id,
};
// Act
var result = await reservationsService.EditAsync(model);
// Assert
Assert.True(result, errorMessage + " " + "Returns false.");
}
public async Task EditAsync_WithIncorrectProperty_ShouldThrowArgumentNullException()
{
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var reservationRepository = new EfDeletableEntityRepository <Reservation>(context);
var reservationsService = this.GetReservationService(reservationRepository, context);
var seeder = new ReservationsServiceTestsSeeder();
await seeder.SeedReservationAsync(context);
var reservation = context.Reservations.First();
var model = new EditReservationViewModel
{
Id = reservation.Id,
UserId = null,
StartDate = new DateTime(2020, 4, 4),
EndDate = new DateTime(2020, 4, 8),
Adults = 2,
Kids = 1,
ReservationStatusId = null,
PaymentTypeId = null,
TotalAmount = 1000,
TotalDays = 4,
AdvancedPayment = 300,
RoomId = null,
};
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await reservationsService.EditAsync(model);
});
}
public async Task <IActionResult> Edit([Bind("CheckInTime,CheckOutTime,Breakfast,AllInclusive,Id,RoomId,ClientIds")] EditReservationViewModel reservationVM)
{
if (reservationVM.CheckOutTime < reservationVM.CheckInTime)
{
ModelState.AddModelError(string.Empty, "The check-out cannot be before the check-in");
}
var selectedRoom = await _context.Rooms.FindAsync(reservationVM.RoomId);
if (!await _context.IsRoomFreeInPeriod(selectedRoom, reservationVM.CheckInTime, reservationVM.CheckOutTime, reservationVM.Id))
{
ModelState.AddModelError("RoomId", "The selected room is not free during the entire period selected");
}
if (reservationVM.ClientIds != null)
{
if (reservationVM.ClientIds.Count == 0)
{
ModelState.AddModelError("ClientIds", "Select clients");
}
if (selectedRoom.Capacity < reservationVM.ClientIds.Count)
{
ModelState.AddModelError("RoomId", "The selected room doesn't have enough capacity for the clients");
}
}
else
{
ModelState.AddModelError("ClientIds", "Select clients");
}
if (ModelState.IsValid)
{
var currentUser = await _context.Users.FindAsync(_userManager.GetUserId(User));
if (currentUser == null)
{
return(Unauthorized());
}
var reservation = await _context.Reservations.Where(x => x.Id == reservationVM.Id).FirstOrDefaultAsync();
foreach (var item in reservation.ClientReservations)
{
_context.Remove(item);
}
try
{
reservation.AllInclusive = reservationVM.AllInclusive;
reservation.Breakfast = reservationVM.Breakfast;
reservation.CheckInTime = reservationVM.CheckInTime;
reservation.CheckOutTime = reservationVM.CheckOutTime;
reservation.Creator = currentUser;
reservation.ClientReservations = reservationVM.ClientIds.Select(x => _context.Clients.Find(x))
.Select(c => new ClientReservation {
Client = c, Reservation = reservation
}).ToList();
reservation.Room = selectedRoom;
double price = 0;
foreach (var client in reservation.ClientReservations.Select(x => x.Client))
{
price += (client.Mature) ? reservation.Room.Price : reservation.Room.PriceChildren;
}
reservation.TotalPrice = price;
_context.Update(reservation);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ReservationExists(reservationVM.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
reservationVM.AvaiableRooms = await _context.Rooms.OrderBy(x => x.Number).ToListAsync();
reservationVM.AvaiableClients = await _context.Clients.OrderBy(x => x.FirstName).ThenBy(x => x.FirstName).ToListAsync();
return(View(reservationVM));
}
public ActionResult Edit(int id, EditReservationViewModel model)
{
ViewData["Services"] = _context.Service.Where(p => p.ServiceId != 1).ToList();
ViewData["PetServices"] = _context.PetReservationService
.Where(p => p.PetReservationId == id).ToList();
if (!ModelState.IsValid)
{
return(View(model));
}
else
{
model.PetReservation.PetReservationService.Add(new PetReservationService {
PetReservationId = model.PetReservation.PetReservationId, ServiceId = 1
});
if (_context.PetReservationService.Where(p => p.PetReservationId == model.PetReservation.PetReservationId && p.ServiceId == 2).Count() != 0)
{
_context.PetReservationService.Remove(new PetReservationService {
PetReservationId = model.PetReservation.PetReservationId, ServiceId = 2
});
}
if (model.Walk)
{
_context.PetReservationService.Add(new PetReservationService {
PetReservationId = model.PetReservation.PetReservationId, ServiceId = 2
});
}
if (_context.PetReservationService.Where(p => p.PetReservationId == model.PetReservation.PetReservationId && p.ServiceId == 5).Count() != 0)
{
_context.PetReservationService.Remove(new PetReservationService {
PetReservationId = model.PetReservation.PetReservationId, ServiceId = 5
});
}
if (model.PlayTime)
{
_context.PetReservationService.Add(new PetReservationService {
PetReservationId = model.PetReservation.PetReservationId, ServiceId = 5
});
}
if (_context.PetReservationService.Where(p => p.PetReservationId == model.PetReservation.PetReservationId && p.ServiceId == 4).Count() != 0)
{
_context.PetReservationService.Remove(new PetReservationService {
PetReservationId = model.PetReservation.PetReservationId, ServiceId = 4
});
if (_context.Medication.Where(m => m.PetReservationId == model.PetReservation.PetReservationId).Count() != 0)
{
_context.Medication.Remove(model.Medication);
}
}
if (model.Medication.Name != null)
{
_context.PetReservationService.Add(new PetReservationService {
PetReservationId = model.PetReservation.PetReservationId, ServiceId = 4
});
if (model.Medication.MedicationId != 0)
{
_context.Medication.Update(model.Medication);
}
else
{
_context.Medication.Add(model.Medication);
}
}
_context.PetReservation.Update(model.PetReservation);
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
}
public async Task <IActionResult> Edit(EditReservationViewModel reservationEditView)
{
await this.reservationsService.EditAsync(reservationEditView);
return(this.Redirect($"/Administration/Reservation/All"));
}
