public async Task DeleteAmenitiesFromRoo(int roomID, int amenityID)
{
RoomAmenities deletedAmenities = await _context.RoomAmenities.FirstOrDefaultAsync(x => x.RoomID == roomID && x.AmenitiesID == amenityID);
_context.Remove(deletedAmenities);
await _context.SaveChangesAsync();
}
public async void RoomAmenitiesUpdateTest()
{
using (AsyncInnDbContext context = new AsyncInnDbContext(optionsRA))
{
await context.Database.EnsureDeletedAsync();
ra = new RoomAmenities
{
Amenities = new Amenities()
{
Name = "Microwave"
},
Room = new Room()
{
Name = "Ocean View"
}
};
context.RoomAmenities.Add(ra);
await context.SaveChangesAsync();
RoomAmenities roomAmenities = await context.RoomAmenities.FirstOrDefaultAsync(x => x.Amenities.Name == "Microwave");
roomAmenities.Amenities.Name = "Teapot";
context.RoomAmenities.Update(roomAmenities);
await context.SaveChangesAsync();
roomAmenities = await context.RoomAmenities.FirstOrDefaultAsync(x => x.Amenities.Name == "Teapot");
Assert.True(roomAmenities.Amenities.Name == "Teapot");
}
}
// GET: RoomAmenities/Edit/5
public async Task <IActionResult> Edit(int roomID, int amenitiesID)
{
if (roomID == 0 || amenitiesID == 0)
{
return(NotFound());
}
RoomAmenities roomAmenities = await _context.RoomAmenities
.FirstOrDefaultAsync(ra => ra.RoomID == roomID && ra.AmenitiesID == amenitiesID);
if (roomAmenities == null)
{
return(NotFound());
}
Room room = await _context.Rooms.FirstOrDefaultAsync(r => r.ID == roomID);
roomAmenities.Room = room;
Amenities amenities = await _context.Amenities.FirstOrDefaultAsync(a => a.ID == amenitiesID);
roomAmenities.Amenitites = amenities;
ViewData["RoomID"] = new SelectList(_context.Rooms, "ID", "Name", roomAmenities.RoomID);
ViewData["AmenitiesID"] = new SelectList(_context.Amenities, "ID", "Name", roomAmenities.AmenitiesID);
return(View(roomAmenities));
}
public void Delete(int id)
{
bool bIsSuccess = false;
using (var oTrans = db.Database.BeginTransaction())
{
try
{
#region Deleting RoomAmenities
RoomAmenities oRoomAmenitiesDelete = db.RoomAmenities.Find(id);
db.RoomAmenities.Remove(oRoomAmenitiesDelete);
bIsSuccess = db.SaveChanges() > 0 ? true : false;
#endregion
bIsSuccess = true;
}
catch (Exception Ex)
{
oTrans.Rollback();
}
finally
{
if (bIsSuccess)
{
oTrans.Commit();
}
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("RoomID,AmenitiesID")] RoomAmenities roomAmenities)
{
if (id != roomAmenities.AmenitiesID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(roomAmenities);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RoomAmenitiesExists(roomAmenities.AmenitiesID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["RoomID"] = new SelectList(_context.Room, "ID", "Name", roomAmenities.RoomID);
ViewData["AmenitiesID"] = new SelectList(_context.Amenities, "ID", "Name", roomAmenities.AmenitiesID);
return(View(roomAmenities));
}
public void CanGetAmenIDofRoomAmenities()
{
RoomAmenities roomAmen = new RoomAmenities();
roomAmen.AmenitiesID = 1;
Assert.True(roomAmen.AmenitiesID == 1);
}
// public void Post([FromBody] string value)
public void Post([FromBody] RoomAmenities p_oRoomAmenities)
{
bool bIsSuccess = false;
using (var oTrans = db.Database.BeginTransaction())
{
try
{
RoomAmenities oRoomAmenitiesAdd = new RoomAmenities();
oRoomAmenitiesAdd.RoomId = p_oRoomAmenities.RoomId;
oRoomAmenitiesAdd.AmenitiesId = p_oRoomAmenities.AmenitiesId;
db.RoomAmenities.Add(oRoomAmenitiesAdd);
bIsSuccess = db.SaveChanges() > 0 ? true : false;
}
catch (Exception Ex)
{
oTrans.Rollback();
}
finally
{
if (bIsSuccess)
{
oTrans.Commit();
}
}
}
}
public async void RoomAmenitiesDeleteTest()
{
using (AsyncInnDbContext context = new AsyncInnDbContext(optionsRA))
{
await context.Database.EnsureDeletedAsync();
ra = new RoomAmenities
{
Amenities = new Amenities()
{
Name = "Microwave"
},
Room = new Room()
{
Name = "Ocean View"
}
};
context.RoomAmenities.Add(ra);
await context.SaveChangesAsync();
RoomAmenities roomAmenities = await context.RoomAmenities.FirstOrDefaultAsync(x => x.Amenities.Name == "Microwave");
context.RoomAmenities.Remove(roomAmenities);
await context.SaveChangesAsync();
var allRoomAmenities = await context.RoomAmenities.ToListAsync();
Assert.DoesNotContain(roomAmenities, allRoomAmenities);
}
}
public async Task <IActionResult> Edit(int id, [Bind("RoomAmenitiesId,RoomId,AmenitiesId")] RoomAmenities roomAmenities)
{
if (id != roomAmenities.RoomAmenitiesId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(roomAmenities);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RoomAmenitiesExists(roomAmenities.RoomAmenitiesId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(roomAmenities));
}
public async void CanUpdateRoomAmenitiesFromDb()
{
// setup our db context
// set value
DbContextOptions <AsyncInnDbContext> options =
new DbContextOptionsBuilder <AsyncInnDbContext>()
.UseInMemoryDatabase("GetRoomAmenitiesUpdateFromDb")
.Options;
RoomAmenities roomAmenities = new RoomAmenities();
// UPDATE: use a clean context instance for test
using (AsyncInnDbContext context = new AsyncInnDbContext(options))
{
roomAmenities.RoomId = 999;
context.Update(roomAmenities);
context.SaveChanges();
}
using (AsyncInnDbContext context = new AsyncInnDbContext(options))
{
var entity = await context.RoomAmenities.FirstOrDefaultAsync(x => x.RoomId == 999);
Assert.Equal(999, entity.RoomId);
}
}
public void CanGetRoomAmenitiesRoomID()
{
RoomAmenities roomAmenities = new RoomAmenities();
roomAmenities.RoomID = 2;
Assert.Equal(2, roomAmenities.RoomID);
}
public async Task <IActionResult> PutRoomAmenities(string id, RoomAmenities roomAmenities)
{
if (id != roomAmenities.AmenitiesID)
{
return(BadRequest());
}
_context.Entry(roomAmenities).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RoomAmenitiesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <RoomAmenities> > PostRoomAmenities(int roomId, int amenitiesId)
{
RoomAmenities newAmenities = new RoomAmenities();
newAmenities.RoomID = roomId;
newAmenities.AmenitiesID = amenitiesId;
_context.RoomAmenities.Add(newAmenities);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (RoomAmenitiesExists(newAmenities.AmenitiesID))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtAction("GetRoomAmenities", new { id = newAmenities.AmenitiesID }, newAmenities));
}
public void CanGetRoomAmenitiesID()
{
RoomAmenities roomAmenities = new RoomAmenities();
roomAmenities.AmenitiesID = 1;
Assert.Equal(1, roomAmenities.AmenitiesID);
}
public void Put(int id, [FromBody] RoomAmenities p_oRoomAmenities)
{
bool bIsSuccess = false;
using (var oTrans = db.Database.BeginTransaction())
{
try
{
RoomAmenities oRoomAmenitiesUpdate = db.RoomAmenities.Find(id);
oRoomAmenitiesUpdate.RoomId = p_oRoomAmenities.RoomId;
oRoomAmenitiesUpdate.AmenitiesId = p_oRoomAmenities.AmenitiesId;
db.Update(oRoomAmenitiesUpdate);
bIsSuccess = db.SaveChanges() > 0 ? true : false;
}
catch (Exception Ex)
{
oTrans.Rollback();
}
finally
{
if (bIsSuccess)
{
oTrans.Commit();
}
}
}
}
public async Task RemoveAmenityFromRoom(int roomID, int amenityID)
{
RoomAmenities chosenToRemove = await _context.RoomAmenities.FirstOrDefaultAsync(x => x.RoomID == roomID && x.AmenitiesID == amenityID);
_context.Remove(chosenToRemove);
await _context.SaveChangesAsync();
}
public async void CanDeleteRoomAmenity()
{
/// Can delete a room amenity
DbContextOptions <AsyncInnDbContext> options = new DbContextOptionsBuilder <AsyncInnDbContext>().UseInMemoryDatabase("DeleteRoomAmenities").Options;
using (AsyncInnDbContext context = new AsyncInnDbContext(options))
{
RoomAmenities amenRoom = new RoomAmenities();
amenRoom.AmenitiesID = 3;
amenRoom.RoomID = 23;
RoomAmenities amenRoom2 = new RoomAmenities();
amenRoom2.AmenitiesID = 33;
amenRoom2.RoomID = 53;
RoomAmenitiesController amenController = new RoomAmenitiesController(context);
await amenController.Create(amenRoom);
await amenController.Delete2(amenRoom);
var result = context.RoomAmenities.FirstOrDefault(ho => ho.AmenitiesID == 3 && ho.RoomID == 23);
Assert.Null(result);
}
}
public void CanSetRoomAmenitiesID()
{
RoomAmenities roomAmenities = new RoomAmenities();
roomAmenities.AmenitiesID = 1;
roomAmenities.AmenitiesID = 2;
Assert.Equal(2, roomAmenities.AmenitiesID);
}
public void CanGetRoomAmenitiesRoomID()
{
RoomAmenities roomAmenities = new RoomAmenities();
roomAmenities.RoomID = 1;
Assert.True(roomAmenities.RoomID == 1);
}
public void CanSetRoomIDofRoomAmenities()
{
RoomAmenities roomAmen = new RoomAmenities();
roomAmen.RoomID = 0;
roomAmen.RoomID = 1;
Assert.True(roomAmen.RoomID == 1);
}
public void CanSetRoomAmenitiesAmenitiesID()
{
RoomAmenities roomAmenities = new RoomAmenities();
roomAmenities.AmenitiesID = 1;
roomAmenities.AmenitiesID = 2;
Assert.True(roomAmenities.AmenitiesID == 2);
}
public async Task AddAmenityToRoom(int roomID, int amenityID)
{
RoomAmenities newRoomAmenity = new RoomAmenities();
newRoomAmenity.RoomID = roomID;
newRoomAmenity.AmenitiesID = amenityID;
_context.RoomAmenities.Add(newRoomAmenity);
await _context.SaveChangesAsync();
}
public void CanGetAmentiesRoomID()
{
RoomAmenities roomAmen = new RoomAmenities();
roomAmen.AmenitiesID = 1;
roomAmen.RoomID = 1;
Assert.Equal(1, roomAmen.RoomID);
}
public void GetAmenitiesID()
{
// get amenities ID number
RoomAmenities amenRoom = new RoomAmenities();
amenRoom.AmenitiesID = 3;
amenRoom.RoomID = 23;
Assert.Equal(3, amenRoom.AmenitiesID);
}
public async Task <IActionResult> Create([Bind("AmenitiesID,RoomID")] RoomAmenities roomAmenities)
{
if (ModelState.IsValid)
{
Room room = await _rooms.GetRoom(roomAmenities.RoomID);
return(RedirectToAction(nameof(Index)));
}
return(View(roomAmenities));
}
public void GetAmenitiesRoomID()
{
/// can get amenities room id
RoomAmenities amenRoom = new RoomAmenities();
amenRoom.AmenitiesID = 3;
amenRoom.RoomID = 23;
Assert.Equal(23, amenRoom.RoomID);
}
public void SetRoomAmenities()
{
RoomAmenities roomAmenities = new RoomAmenities();
roomAmenities.AmenitiesID = 8;
roomAmenities.RoomID = 11;
Assert.Equal(8, roomAmenities.AmenitiesID);
Assert.Equal(11, roomAmenities.RoomID);
}
public void CanSetAmenitesRoomID()
{
RoomAmenities roomAmen = new RoomAmenities();
roomAmen.AmenitiesID = 1;
roomAmen.RoomID = 1;
roomAmen.RoomID = 2;
Assert.Equal(2, roomAmen.RoomID);
}
/// <summary>
/// add an amenity to a room
/// </summary>
/// <param name="amenityID">the ID of the amenity to be added</param>
/// <param name="roomID">the ID of the room to add it to</param>
/// <returns></returns>
public async Task AddAmenityToRoom(int amenityID, int roomID)
{
RoomAmenities roomAmenities = new RoomAmenities()
{
AmenityID = amenityID, RoomID = roomID
};
_context.Entry(roomAmenities).State = EntityState.Added;
await _context.SaveChangesAsync();
}
public void CanGetRoomAmenitiesTest()
{
RoomAmenities ra = new RoomAmenities();
ra.RoomID = 1;
ra.AmenitiesID = 2;
Assert.Equal(1, ra.RoomID);
Assert.Equal(2, ra.AmenitiesID);
}
