public async Task <bool> EditAsync(EditRoomViewModel roomEditViewModel)
{
var room = this.roomRepository.All().FirstOrDefault(r => r.Id == roomEditViewModel.Id);
if (room == null)
{
throw new ArgumentNullException(string.Format(string.Format(ServicesDataConstants.InvalidRoomIdErrorMessage, roomEditViewModel.Id)));
}
if (roomEditViewModel.RoomNumber == null ||
roomEditViewModel.Description == null ||
roomEditViewModel.RoomTypeId == null)
{
throw new ArgumentNullException(string.Format(ServicesDataConstants.InvalidPropertyErrorMessage));
}
room.RoomNumber = roomEditViewModel.RoomNumber;
room.Description = roomEditViewModel.Description;
room.RoomTypeId = roomEditViewModel.RoomTypeId;
this.roomRepository.Update(room);
var result = await this.roomRepository.SaveChangesAsync();
return(result > 0);
}
public ActionResult Edit(EditRoomViewModel editRoomViewModel)
{
if (!ModelState.IsValid)
{
return(View(editRoomViewModel));
}
if (editRoomViewModel.ImageFile != null)
{
string filename = Path.GetFileNameWithoutExtension(editRoomViewModel.ImageFile.FileName);
string extension = Path.GetExtension(editRoomViewModel.ImageFile.FileName);
filename = filename + DateTime.Now.ToString("yymmssfff") + extension;
editRoomViewModel.Image = "~/Images/" + filename;
filename = Path.Combine(Server.MapPath("~/Images/"), filename);
editRoomViewModel.ImageFile.SaveAs(filename);
}
else
{
editRoomViewModel.Image = "~/Images/noimage.jpg";
}
db.Entry(EditRoomViewModelToRoom.CreateMapper()
.Map <EditRoomViewModel, Room>(editRoomViewModel)).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <bool> EditRoomAsync(string id, EditRoomViewModel input)
{
var currentRoom = this.GetRoomById(id);
if (currentRoom != null)
{
currentRoom.RoomType = input.RoomType;
currentRoom.Price = input.Price;
currentRoom.NumberOfBeds = input.NumberOfBeds;
currentRoom.HasWifi = input.HasWifi;
currentRoom.HasAirConditioner = input.HasAirConditioner;
currentRoom.HasBathroom = input.HasBathroom;
currentRoom.HasHeater = input.HasHeater;
currentRoom.HasMountainView = input.HasMountainView;
currentRoom.HasPhone = input.HasPhone;
currentRoom.HasRoomService = input.HasRoomService;
currentRoom.HasSeaView = input.HasSeaView;
currentRoom.HasTv = input.HasTv;
this.repository.Update(currentRoom);
await this.repository.SaveChangesAsync();
return(true);
}
throw new InvalidOperationException(GlobalConstants.InvalidOperationExceptionForRoomEdit);
}
public ActionResult EditRoom(int?id)
{
if (id == null)
{
return(View("Error"));
}
GetRoomById_Result RoomToEdit;
RoomToEdit = _context.GetRoomById(id).FirstOrDefault();
if (RoomToEdit == null)
{
return(View("Error"));
}
EditRoomViewModel RoomVM = new EditRoomViewModel
{
ID = RoomToEdit.ID,
RoomNo = RoomToEdit.RoomNo,
IsACEquipped = RoomToEdit.IsACEquipped,
IsDisabled = RoomToEdit.IsDisabled,
Price = RoomToEdit.Price,
RmType = Enum.GetName(typeof(RoomType), RoomToEdit.RmType),
NoOfBeds = Enum.GetName(typeof(BedNo), RoomToEdit.NoOfBeds),
};
return(View(RoomVM));
}
public async Task EditAsync_WithCorrectData_ShouldReturnCorrectResult()
{
var errorMessagePrefix = "RoomsService EditAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var seeder = new RoomsServiceTestsSeeder();
await seeder.SeedDataForEditAsyncMethodAsync(context);
var roomsRepository = new EfDeletableEntityRepository <Room>(context);
var roomTypesRepository = new EfDeletableEntityRepository <RoomType>(context);
var roomsService = this.GetRoomsService(roomsRepository, roomTypesRepository, context);
var room = context.Rooms.First();
var model = new EditRoomViewModel
{
Id = room.Id,
RoomNumber = "Test-Edited",
RoomTypeId = roomTypesRepository.All().Skip(1).Take(1).Select(x => x.Id).FirstOrDefault(),
Description = "TestDescription-Edited",
};
// Act
var result = await roomsService.EditAsync(model);
// Assert
Assert.True(result, errorMessagePrefix + " " + "Returns false.");
}
public async Task <EditRoomViewModel> GetRoomForEditAsync(string id)
{
var room = this.GetRoomById(id);
if (room != null)
{
var result = new EditRoomViewModel()
{
RoomType = room.RoomType,
Price = room.Price,
NumberOfBeds = room.NumberOfBeds,
HasWifi = room.HasWifi,
HasAirConditioner = room.HasAirConditioner,
HasBathroom = room.HasBathroom,
HasHeater = room.HasHeater,
HasMountainView = room.HasMountainView,
HasPhone = room.HasPhone,
HasRoomService = room.HasRoomService,
HasSeaView = room.HasSeaView,
HasTv = room.HasTv,
};
return(result);
}
throw new InvalidOperationException(GlobalConstants.InvalidOperationExceptionForRoomSearchForEdit);
}
public async Task EditAsync_WithIncorrectProperty_ShouldThrowArgumentNullException()
{
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var seeder = new RoomsServiceTestsSeeder();
await seeder.SeedDataForEditAsyncMethodAsync(context);
var roomsRepository = new EfDeletableEntityRepository <Room>(context);
var roomTypesRepository = new EfDeletableEntityRepository <RoomType>(context);
var roomsService = this.GetRoomsService(roomsRepository, roomTypesRepository, context);
var room = context.Rooms.First();
var model = new EditRoomViewModel
{
Id = room.Id,
RoomNumber = null,
RoomTypeId = roomTypesRepository.All().Skip(1).Take(1).Select(x => x.Id).FirstOrDefault(),
Description = "TestDescription-Edited",
};
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await roomsService.EditAsync(model);
});
}
public async Task EditAsync_WithNonExisterntId_ShouldThrowArgumentNullException()
{
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var seeder = new RoomsServiceTestsSeeder();
await seeder.SeedDataForEditAsyncMethodAsync(context);
var roomsRepository = new EfDeletableEntityRepository <Room>(context);
var roomTypesRepository = new EfDeletableEntityRepository <RoomType>(context);
var roomsService = this.GetRoomsService(roomsRepository, roomTypesRepository, context);
var nonExistentId = Guid.NewGuid().ToString();
var editModel = new EditRoomViewModel
{
Id = nonExistentId,
RoomNumber = "Test-Edited",
RoomTypeId = roomTypesRepository.All().First().Id,
Description = "TestDescription-Edited",
};
// Act
// Assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await roomsService.EditAsync(editModel);
});
}
public async Task <IActionResult> EditRoom(EditRoomViewModel model)
{
if (ModelState.IsValid)
{
Room editRoom = await this._applicationContext.Rooms.FindAsync(model.OldNumber);
if (editRoom != null)
{
editRoom.Floor = model.Floor;
editRoom.Capacity = model.Capacity;
editRoom.Price = model.Price;
editRoom.IsReady = model.IsReady;
editRoom.Comfort = model.Comfort;
editRoom.Description = model.Description;
this._applicationContext.Rooms.Update(editRoom);
await this._applicationContext.SaveChangesAsync();
await this._applicationContext.Database.ExecuteSqlRawAsync(
"UPDATE Rooms SET Number={0} WHERE Number={1}",
model.Number, model.OldNumber);
return(RedirectToAction(nameof(Rooms)));
}
else
{
return(View("Error"));
}
}
return(View(model));
}
public async Task EditAsync_WithCorrectData_ShouldSuccessfullyEdit()
{
var errorMessagePrefix = "RecipeService EditAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var seeder = new RoomsServiceTestsSeeder();
await seeder.SeedDataForEditAsyncMethodAsync(context);
var roomRepository = new EfDeletableEntityRepository <Room>(context);
var roomTypesRepository = new EfDeletableEntityRepository <RoomType>(context);
var roomsService = this.GetRoomsService(roomRepository, roomTypesRepository, context);
var room = context.Rooms.First();
var editModel = new EditRoomViewModel
{
Id = room.Id,
RoomNumber = "Test-Edited",
RoomTypeId = roomTypesRepository.All().Skip(1).Take(1).Select(x => x.Id).FirstOrDefault(),
Description = "TestDescription-Edited",
};
// Act
await roomsService.EditAsync(editModel);
var actualResult = roomRepository.All().First();
var expectedResult = editModel;
// Assert
Assert.True(expectedResult.RoomNumber == actualResult.RoomNumber, errorMessagePrefix + " " + "RoomNumer is not returned properly.");
Assert.True(expectedResult.Description == actualResult.Description, errorMessagePrefix + " " + "Description are not returned properly.");
Assert.True(expectedResult.RoomTypeId == actualResult.RoomTypeId, errorMessagePrefix + " " + "RoomTypeId is not returned properly.");
}
public IActionResult Edit(int id)
{
var room = unit.RoomRepository.GetRoom(id);
EditRoomViewModel model = new EditRoomViewModel
{
Address = room.Address,
Advance = room.Advance,
City = room.City,
ConstructionYear = room.ConstructionYear,
Description = room.FullDescription,
Price = room.Price,
SquareMetrage = room.SquareMetrage,
Name = room.Name,
Floor = room.Floor,
Id = room.RoomId,
HaveFurnishings = room.HaveFurnishings,
NumberOfFlatmates = room.NumberOfFlatmates,
TotalArea = room.TotalArea,
AgencyName = room.AgencyName,
MainImageName = room.MainImageName
};
return(View(model));
}
public async Task GetViewModelByIdAsync_WithExistentId_ShouldReturnCorrectResult()
{
var errorMessagePrefix = "RoomsService GetViewModelByIdAsync() method does not work properly.";
// Arrange
MapperInitializer.InitializeMapper();
MapperInitializer.InitializeMapper();
var context = HotelDbContextInMemoryFactory.InitializeContext();
var seeder = new RoomsServiceTestsSeeder();
await seeder.SeedRoomAsync(context);
var roomsRepository = new EfDeletableEntityRepository <Room>(context);
var roomTypesRepository = new EfDeletableEntityRepository <RoomType>(context);
var roomsService = this.GetRoomsService(roomsRepository, roomTypesRepository, context);
var roomId = roomsRepository.All().First().Id;
// Act
var actualResult = await roomsService.GetViewModelByIdAsync <EditRoomViewModel>(roomId);
var expectedResult = new EditRoomViewModel
{
Id = roomsRepository.All().First().Id,
RoomNumber = "Test-1",
RoomTypeId = roomTypesRepository.All().First().Id,
Description = "TestDescription",
};
// Assert
Assert.True(expectedResult.Id == actualResult.Id, errorMessagePrefix + " " + "Id is not returned properly.");
Assert.True(expectedResult.RoomNumber == actualResult.RoomNumber, errorMessagePrefix + " " + "RoomNumer is not returned properly.");
Assert.True(expectedResult.Description == actualResult.Description, errorMessagePrefix + " " + "Description are not returned properly.");
Assert.True(expectedResult.RoomTypeId == actualResult.RoomTypeId, errorMessagePrefix + " " + "RoomTypeId is not returned properly.");
}
public IActionResult Edit(EditRoomViewModel model)
{
if (ModelState.IsValid)
{
var room = unit.RoomRepository.GetRoom(model.Id);
room.Address = model.Address;
room.Advance = model.Advance;
room.City = model.City;
room.ConstructionYear = model.ConstructionYear;
room.FullDescription = model.Description;
room.Price = model.Price;
room.SquareMetrage = model.SquareMetrage;
room.Name = model.Name;
room.Floor = model.Floor;
room.HaveFurnishings = model.HaveFurnishings;
room.NumberOfFlatmates = model.NumberOfFlatmates;
room.TotalArea = model.TotalArea;
if (model.MainImage != null)
{
System.IO.File.Delete(Path.Combine(room.MainImage.PhotoPath, room.MainImage.PhotoName));
string name = manager.ReturnUniqueName(model.MainImage);
manager.UploadPhoto(model.MainImage, Path.Combine(hostEnvironment.WebRootPath, "images"), name);
room.MainImage = new Photo
{
PhotoName = name,
PhotoPath = Path.Combine(hostEnvironment.WebRootPath, "images")
};
room.MainImageName = name;
}
if (model.Images != null)
{
List <string> photoNames = new List <string>();
foreach (var image in room.Images)
{
System.IO.File.Delete(Path.Combine(image.PhotoPath, image.PhotoName));
}
foreach (var photo in model.Images)
{
var name = manager.ReturnUniqueName(photo);
photoNames.Add(name);
manager.UploadPhoto(photo, room.Images.FirstOrDefault().PhotoPath, name);
}
foreach (var photoName in photoNames)
{
room.Images.Add(new Photo {
PhotoName = photoName, PhotoPath = Path.Combine(hostEnvironment.WebRootPath, "images")
});
}
}
unit.RoomRepository.EditRoom(room);
unit.SaveData();
return(RedirectToAction("Success", "Customers"));
}
return(View(model));
}
public async Task <IActionResult> Edit(string id)
{
if (id == null)
{
return(NotFound());
}
var room = await _context.Rooms.FindAsync(id);
if (room == null)
{
return(NotFound());
}
await _context.UpdateRoom(room);
var roomVM = new EditRoomViewModel
{
Capacity = room.Capacity,
Free = room.Free,
Id = room.Id,
Number = room.Number,
Price = room.Price,
PriceChildren = room.PriceChildren,
Type = room.Type
};
return(View(roomVM));
}
public async Task <IActionResult> Edit(EditRoomViewModel model)
{
int er = 0;
Room room = await db.Rooms.FirstOrDefaultAsync(t => t.RoomID == model.Id);
if (ModelState.IsValid && (model.RoomType == room.RoomType || (er = db.Rooms.Count(p => p.RoomType == model.RoomType)) == 0))
{
if (room == null)
{
ErrorViewModel error = new ErrorViewModel
{
RequestId = "Error! Empty model was sent"
};
return(View("Error", error));
}
room.RoomType = model.RoomType;
room.RoomCapacity = model.RoomCapacity;
room.RoomDescription = model.RoomDescription;
room.RoomPrice = model.RoomPrice;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
if (er != 0)
{
ModelState.AddModelError("RoomType", "Record with the same type already exists");
}
return(View(model));
}
public async Task <IActionResult> Edit(int?id)
{
if (id != null)
{
Room room = await db.Rooms.FirstOrDefaultAsync(t => t.RoomID == id);
if (room == null)
{
ErrorViewModel error = new ErrorViewModel
{
RequestId = "Error! There is no record in the database with the id passed = " + id
};
return(View("Error", error));
}
EditRoomViewModel model = new EditRoomViewModel
{
Id = room.RoomID,
RoomType = room.RoomType,
RoomCapacity = room.RoomCapacity,
RoomDescription = room.RoomDescription,
RoomPrice = room.RoomPrice
};
return(View(model));
}
else
{
ErrorViewModel error = new ErrorViewModel {
RequestId = "Error! Missing id in request parameters"
};
return(View("Error", error));
}
}
public ActionResult EditChatRoom(int id)
{
var editModel = new EditRoomViewModel()
{
ChatRoomId = id
};
return(PartialView(editModel));
}
public async Task <IActionResult> UpdateRoom(EditRoomViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View("EditRoom", viewModel));
}
return(await chatRoomsManager.UpdateRoom(mapper.Map <ChatRoom>(viewModel))
? (IActionResult)RedirectToAction("Rooms").PushAlert($"Room #{viewModel.Id} has been updated")
: this.ErrorPage());
}
public ActionResult EditChatRoom(EditRoomViewModel editModel)
{
if (!ModelState.IsValid)
{
return(PartialView(editModel));
}
_chatRoomService.EditChatRoom(editModel.ChatRoomId, editModel.NewTitle);
_commitProvider.SaveChanges();
return(Redirect(Request.UrlReferrer.PathAndQuery));
}
public async Task <IActionResult> Edit([FromRoute] string roomId, EditRoomViewModel input)
{
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
await this.roomsService.EditRoomAsync(roomId, input);
this.TempData["InfoMessage"] = GlobalConstants.EditRoomTempDataSuccess;
return(this.RedirectToAction("All"));
}
public IActionResult Edit(EditRoomViewModel editRoom)
{
bool result = roomServices.EditRoom(editRoom);
if (!result)
{
return(View(editRoom));
}
else
{
return(Redirect("/Room/All/"));
}
}
public async Task <IActionResult> EditRoom(EditRoomViewModel model)
{
if (this.ModelState.IsValid)
{
var room = _converterHelper.ToRoomEntity(model);
var specialityId = await _specialityRepository.UpdateRoomAsync(room);
if (specialityId != 0)
{
return(this.RedirectToAction($"Details/{specialityId}"));
}
}
return(View(model));
}
public IActionResult Edit(int id)
{
//Room roomForEdit = this.context.Rooms.Find(id);
Room roomForEdit = roomServices.GetRoom(id);
EditRoomViewModel model = new EditRoomViewModel
{
Id = roomForEdit.Id,
Capacity = roomForEdit.Capacity,
RoomType = roomForEdit.RoomType,
FreeRoom = roomForEdit.FreeRoom,
PricePerAdult = roomForEdit.PricePerAdult,
PricePerKid = roomForEdit.PricePerKid,
RoomNumber = roomForEdit.RoomNumber
};
return(View(model));
}
public async Task <IActionResult> Edit(int id, EditRoomViewModel viewModel)
{
if (id != viewModel.Room.RoomID)
{
return(View("CustomNotFound"));
}
if (ModelState.IsValid)
{
_context.Update(viewModel.Room);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
viewModel.Locations = new SelectList(_context.Location, "LocationID", "NameAndPlace", viewModel.Room.LocationID);
return(View(viewModel));
}
public async Task <IActionResult> Edit([Bind("Capacity,Type,Free,Price,PriceChildren,Number,Id")] EditRoomViewModel roomVM)
{
if (roomVM.Price < 0)
{
ModelState.AddModelError("Price", "The price must be positive");
}
if (roomVM.PriceChildren < 0)
{
ModelState.AddModelError("PriceChildren", "The price for children must be positive");
}
var room = await _context.Rooms.FindAsync(roomVM.Id);
if (await _context.Rooms.Where(x => x.Number == roomVM.Number).CountAsync() != 0 && roomVM.Number != room.Number)
{
ModelState.AddModelError("Number", "Room with the same number already exists");
}
if (ModelState.IsValid)
{
try
{
room.Capacity = roomVM.Capacity;
room.Type = roomVM.Type;
room.Free = roomVM.Free;
room.Price = roomVM.Price;
room.PriceChildren = roomVM.PriceChildren;
room.Number = roomVM.Number;
_context.Update(room);
await _context.SaveChangesAsync();
}
catch (Exception)
{
if (!RoomExists(roomVM.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(roomVM));
}
// GET: Room/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(View("CustomNotFound"));
}
EditRoomViewModel viewModel = new EditRoomViewModel();
viewModel.Room = await _context.Room.FindAsync(id);
if (viewModel.Room == null)
{
return(View("CustomNotFound"));
}
viewModel.Locations = new SelectList(_context.Location, "LocationID", "NameAndPlace", viewModel.Room.LocationID);
return(View(viewModel));
}
// GET: Admin/Admin/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Room room = db.Rooms.Find(id);
if (room == null)
{
return(HttpNotFound());
}
var editRoomViewModel = new EditRoomViewModel(room)
{
};
return(View(editRoomViewModel));
}
public ActionResult AddNewRoom(EditRoomViewModel model)
{
if (ModelState.IsValid)
{
HashSet <int> RoomNos = new HashSet <int>(_context.GetRooms().Select(r => r.RoomNo).ToList());
if (RoomNos.Contains(model.RoomNo))
{
ModelState.AddModelError("", "Room number exists!");
return(View(model));
}
else
{
_context.AddNewRoom(model.RoomNo, model.IsACEquipped, model.IsDisabled, model.Price, (int)Enum.Parse(typeof(RoomType), model.RmType), (int)Enum.Parse(typeof(BedNo), model.NoOfBeds));
}
return(RedirectToAction("ManageRooms"));
}
return(View(model));
}
public ActionResult EditRoom(EditRoomViewModel model)
{
if (ModelState.IsValid)
{
int OriNo = _context.GetRoomById(model.ID).FirstOrDefault().RoomNo;
HashSet <int> RoomNos = new HashSet <int>(_context.GetRooms().Select(r => r.RoomNo).Where(no => no != OriNo).ToList());
if (RoomNos.Contains(model.RoomNo))
{
ModelState.AddModelError("", "Room number exists!");
return(View(model));
}
else
{
_context.UpdateExistingRoom(model.ID, model.RoomNo, model.IsACEquipped, model.IsDisabled, model.Price, (int)Enum.Parse(typeof(RoomType), model.RmType), (int)Enum.Parse(typeof(BedNo), model.NoOfBeds));
}
return(RedirectToAction("ManageRooms"));
}
return(View(model));
}
public async Task <IActionResult> EditRoom(byte roomNumber)
{
Room room = await this._applicationContext.Rooms.FindAsync(roomNumber);
if (room != null)
{
EditRoomViewModel model = new EditRoomViewModel
{
OldNumber = room.Number,
Number = room.Number,
Floor = room.Floor,
Capacity = room.Capacity,
Price = room.Price,
IsReady = room.IsReady,
Comfort = room.Comfort,
Description = room.Description
};
return(View(model));
}
return(View("Error"));
}
