public async void UpdateAmenitiesWorks()
{
DbContextOptions <AsyncInnDbContext> options =
new DbContextOptionsBuilder <AsyncInnDbContext>
().UseInMemoryDatabase("UpdateAmenities").Options;
using (AsyncInnDbContext context = new AsyncInnDbContext(options))
{
// arrange
Amenities amenities = new Amenities();
amenities.Name = "Iron";
amenities.ID = 1;
// Act
AmenetiesManagementService service = new AmenetiesManagementService(context);
await service.CreateAmeneties(amenities);
amenities.Name = "Bar";
await service.UpdateAmeneties(amenities);
// Assert
Assert.Equal("Bar", amenities.Name);
}
}
public void CanGetNameOfAmenities()
{
Amenities amenity = new Amenities();
amenity.Name = "Fridge";
Assert.True(amenity.Name == "Fridge");
}
public void AmenitiesPropertiesID()
{
Amenities amenities = new Amenities();
var result = amenities.ID = 5;
Assert.Equal(result, amenities.ID);
}
// CRU[D]
public async Task DeleteAmenitie(int id)
{
Amenities amenitie = await _context.Amenities.FindAsync(id);
_context.Amenities.Remove(amenitie);
await _context.SaveChangesAsync();
}
//delete
public async Task DeleteAmenity(int id)
{
Amenities amenity = _context.Amenities.FirstOrDefault(a => a.ID == id);
_context.Amenities.Remove(amenity);
await _context.SaveChangesAsync();
}
public void Delete(int id)
{
bool bIsSuccess = false;
using (var oTrans = db.Database.BeginTransaction())
{
try
{
#region Deleting Amenities
Amenities oAmenitiesUpdateDeleted = db.Amenities.Find(id);
oAmenitiesUpdateDeleted.IsActive = false;
db.Amenities.Update(oAmenitiesUpdateDeleted);
bIsSuccess = db.SaveChanges() > 0 ? true : false;
#endregion
}
catch (Exception Ex)
{
oTrans.Rollback();
}
finally
{
if (bIsSuccess)
{
oTrans.Commit();
}
}
}
}
public void Put(int id, [FromBody] Amenities p_oAmenities)
{
bool bIsSuccess = false;
using (var oTrans = db.Database.BeginTransaction())
{
try
{
Amenities oAmenitiesUpdate = db.Amenities.Find(id);
oAmenitiesUpdate.AmenitiesName = p_oAmenities.AmenitiesName;
oAmenitiesUpdate.IsActive = p_oAmenities.IsActive;
db.Update(oAmenitiesUpdate);
bIsSuccess = db.SaveChanges() > 0 ? true : false;
}
catch (Exception Ex)
{
oTrans.Rollback();
}
finally
{
if (bIsSuccess)
{
oTrans.Commit();
}
}
}
}
public async Task <Amenities> CreateAmenities(Amenities amenities)
{
_context.Amenities.Add(amenities);
await _context.SaveChangesAsync();
return(amenities);
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Name")] Amenities amenities)
{
if (id != amenities.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _context.UpdateAmenity(amenities);
}
catch (DbUpdateConcurrencyException)
{
//if (AmenitiesExists(amenities.ID))
//{
// return NotFound();
//}
//else
//{
throw;
//}
}
return(RedirectToAction(nameof(Index)));
}
return(View(amenities));
}
public void GetAmenityName()
{
Amenities amenity = new Amenities();
amenity.Name = "Cable TV";
Assert.Equal("Cable TV", amenity.Name);
}
public async void CanGetAmenitys()
{
DbContextOptions <AsyncInnDbContext> options = new DbContextOptionsBuilder <AsyncInnDbContext>().UseInMemoryDatabase("GetAmenitys").Options;
using (AsyncInnDbContext context = new AsyncInnDbContext(options))
{
Amenities amenity = new Amenities();
amenity.ID = 1;
amenity.Name = "test";
Amenities amenity2 = new Amenities();
amenity2.ID = 2;
amenity2.Name = "test";
AmenitiesService amenitiesService = new AmenitiesService(context);
await amenitiesService.CreateAmenity(amenity);
await amenitiesService.CreateAmenity(amenity2);
var roomsList = await amenitiesService.GetAmenities();
var rooms = roomsList.ToString();
List <Amenities> resultsList = new List <Amenities>();
resultsList.Add(amenity);
resultsList.Add(amenity2);
var results = resultsList.ToString();
Assert.Equal(results, rooms);
}
}
public void SetAmenityName()
{
Amenities amenity = new Amenities();
amenity.Name = "Jacuzzi";
Assert.Equal("Jacuzzi", amenity.Name);
}
public async void CanDeleteAmenity()
{
//testing hotel management service
DbContextOptions <AsyncInnDbContext> options =
new DbContextOptionsBuilder <AsyncInnDbContext>().UseInMemoryDatabase("DeleteAmenity").Options;
using (AsyncInnDbContext context = new AsyncInnDbContext(options))
{
//arrange
Amenities amenity = new Amenities();
amenity.ID = 1;
amenity.Name = "toaster";
//act
AmenityManagementService amenityservice = new AmenityManagementService(context);
await amenityservice.CreateAmenity(amenity);
await amenityservice.DeleteAmenity(1);
var result = context.Amenities.Any(am => am.ID == 1);
//assert
Assert.False(result);
}
}
public async void CanUpdateAmenity()
{
//testing hotel management service
DbContextOptions <AsyncInnDbContext> options =
new DbContextOptionsBuilder <AsyncInnDbContext>().UseInMemoryDatabase("CreateAmenity").Options;
using (AsyncInnDbContext context = new AsyncInnDbContext(options))
{
//arrange
Amenities amenity = new Amenities();
amenity.ID = 1;
amenity.Name = "toaster";
amenity.Name = "breakfast included";
//act
AmenityManagementService amenityservice = new AmenityManagementService(context);
await amenityservice.CreateAmenity(amenity);
await amenityservice.UpdateAmenity(amenity);
var result = context.Amenities.FirstOrDefault(a => a.ID == a.ID);
//assert
Assert.Equal(amenity, result);
}
}
public void CanGetAmenityName()
{
Amenities amenities = new Amenities();
amenities.Name = "Iron";
Amenities.Equals("Iron", amenities.ID);
}
public async void CanEdiAmenity()
{
/// Can edit an existing amenity
DbContextOptions <AsyncInnDbContext> options = new DbContextOptionsBuilder <AsyncInnDbContext>().UseInMemoryDatabase("UpdateAemnity").Options;
using (AsyncInnDbContext context = new AsyncInnDbContext(options))
{
Amenities amen = new Amenities();
amen.ID = 72;
amen.Name = "Poker";
AmenitiesManagementServices amenServices = new AmenitiesManagementServices(context);
await amenServices.CreateAmenity(amen);
Amenities upAmen = await amenServices.GetAmenities(amen.ID);
upAmen.Name = "Black-jack";
await amenServices.UpdateAmenity(upAmen);
var result = context.Amenities.FirstOrDefault(ho => ho.ID == amen.ID);
Assert.Equal("Black-jack", result.Name);
}
}
public async void CanDeleteAmenity()
{
Microsoft.EntityFrameworkCore.DbContextOptions <AsyncInnDbContext> options = new
DbContextOptionsBuilder <AsyncInnDbContext>().UseInMemoryDatabase
("CreateHotel").Options;
using (AsyncInnDbContext context = new AsyncInnDbContext
(options))
{
//Arrange
Amenities amenities = new Amenities();
amenities.ID = 1;
amenities.Name = "Iron";
//Act
AmenityManagerService amenityService = new AmenityManagerService(context);
await amenityService.CreateAmenity(amenities);
await amenityService.DeleteAmenity(1);
var result = await context.Amenities.FirstOrDefaultAsync(h => h.ID == amenities.ID);
Assert.Null(result);
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
int AId = 0;
Session.Remove("Prop_Action");
if (Request.QueryString["AmenitiesID"] != null)
{
AId = Convert.ToInt32(Request.QueryString["AmenitiesID"]);
Session["Prop_Action"] = "U";
}
if (Session["Prop_Action"] == "U")
{
// int proID= int.Parse(Session["Pro_ID"].ToString());
Amenities amenities = new Amenities();
amenities.AmenitiesID = AId;
amenities.SelectOne();
hidAmenitiesID.Value = amenities.AmenitiesID.ToString();
txtAName.Text = amenities.AmenitiesName.ToString();
txtDescription.Text = amenities.Description.ToString();
txtQty.Text = amenities.Quantity.ToString();
txtPrice.Text = amenities.Price.ToString();
}
}
}
// public void Post([FromBody] string value)
public void Post([FromBody] Amenities p_oAmenities)
{
bool bIsSuccess = false;
using (var oTrans = db.Database.BeginTransaction())
{
try
{
Amenities oAmenitiesAdd = new Amenities();
oAmenitiesAdd.AmenitiesName = p_oAmenities.AmenitiesName;
oAmenitiesAdd.IsActive = p_oAmenities.IsActive;
db.Amenities.Add(oAmenitiesAdd);
bIsSuccess = db.SaveChanges() > 0 ? true : false;
}
catch (Exception Ex)
{
oTrans.Rollback();
}
finally
{
if (bIsSuccess)
{
oTrans.Commit();
}
}
}
}
/// <summary>
/// Updates an amenity
/// </summary>
/// <param name="amenity">The amenity to update</param>
/// <returns>Task of completion</returns>
public async Task <Amenities> Update(Amenities amenity)
{
_context.Entry(amenity).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(amenity);
}
public async Task DeleteAmenity(int id)
{
Amenities amenity = await GetAmenity(id);
_context.Amenities.Remove(amenity);
await _context.SaveChangesAsync();
}
public void DeleteAmenity(int id)
{
Amenities amenity = _context.Amenities.FirstOrDefault(s => s.ID == id);
_context.Amenities.Remove(amenity);
_context.SaveChanges();
}
public async Task <IActionResult> Edit(int id, [Bind("AmenitiesId,Name")] Amenities amenities)
{
if (id != amenities.AmenitiesId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _amenities.UpdateAmenities(amenities);
}
catch (DbUpdateConcurrencyException)
{
if (!_amenities.AmenitiesExists(amenities.AmenitiesId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(amenities));
}
public async Task <IActionResult> PutAmenities(int id, Amenities amenities)
{
if (id != amenities.ID)
{
return(BadRequest());
}
_context.Entry(amenities).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AmenitiesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void CanGetIDOfAmenities()
{
Amenities amenity = new Amenities();
amenity.ID = 0;
Assert.True(amenity.ID == 0);
}
public async Task <ActionResult <Amenities> > PostAmenities(Amenities amenities)
{
_context.Amenities.Add(amenities);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAmenities", new { id = amenities.ID }, amenities));
}
public void AmenitiesPropertiesName()
{
Amenities amenities = new Amenities();
var result = amenities.Name = "Heating";
Assert.Equal(result, amenities.Name);
}
public void CanGetAmenityID()
{
Amenities amenities = new Amenities();
amenities.ID = 1;
Amenities.Equals(1, amenities.ID);
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Name")] Amenities amenities)
{
if (id != amenities.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _context.EditAmenities(amenities);
//_context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AmenitiesExists(amenities.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(amenities));
}
public async void DeleteAmenitiesWorksAgain()
{
DbContextOptions <AsyncInnDbContext> options =
new DbContextOptionsBuilder <AsyncInnDbContext>
().UseInMemoryDatabase("DeleteAmenities").Options;
using (AsyncInnDbContext context = new AsyncInnDbContext(options))
{
// arrange
Amenities amenities = new Amenities();
amenities.Name = "Bar";
amenities.ID = 2;
// Act
AmenetiesManagementService service = new AmenetiesManagementService(context);
await service.CreateAmeneties(amenities);
await service.DeleteAmenities(2);
var deleted = context.Amenities.FirstOrDefault(r => r.ID == amenities.ID);
// Assert
Assert.Null(deleted);
}
}
