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")); }