public async Task <IActionResult> PutRoomAsync(Guid roomId, [FromBody] Lib.Room room)
{
try
{
_logger.LogInformation("Updating a room");
var roomFromDb = await _repository.ReadRoomAsync(roomId);
roomFromDb.SetLease(room.LeaseStart, room.LeaseEnd);
await _repository.UpdateRoomAsync(roomFromDb);
await _repository.SaveAsync();
_logger.LogInformation("Success. Room has been updated");
return(NoContent());
}
catch (InvalidOperationException ex)
{
_logger.LogError("Room to update was not found in DB", ex);
return(NotFound());
}
catch (ArgumentException ex)
{
_logger.LogError("Lease is invalid", ex);
return(BadRequest());
}
}
public async Task <IActionResult> PostRoomAsync
([FromBody, Bind("ComplexID, RoomID, RoomNumber, NumberOfBeds, NumberOfOccupants, Gender, RoomType, LeaseStart, LeaseEnd")] Lib.Room room)
{
try
{
_logger.LogInformation("Adding a room");
var createdRoom = new Lib.Room
{
ComplexId = room.ComplexId,
RoomId = room.RoomId,
RoomNumber = room.RoomNumber,
NumberOfBeds = room.NumberOfBeds,
NumberOfOccupants = room.NumberOfOccupants,
Gender = room.Gender,
RoomType = room.RoomType
};
createdRoom.SetLease(room.LeaseStart, room.LeaseEnd);
await _repository.CreateRoomAsync(createdRoom);
await _repository.SaveAsync();
_logger.LogInformation("Success. Room has been added");
return(CreatedAtRoute("GetRoom", new { RoomID = createdRoom.RoomId }, createdRoom));
}
catch (ArgumentException ex)
{
_logger.LogInformation("Lease was invalid", ex);
return(BadRequest());
}
}
public async Task PutRoomShouldReturnNotFound()
{
//arrange
var mockRepo = new Mock <IRepository>();
var mockLogger = new Mock <ILogger <ComplexController> >();
mockRepo.Setup(r => r.UpdateRoomAsync(
It.IsAny <Lib.Room>()
)).Throws(new InvalidOperationException());
mockRepo.Setup(r => r.ReadRoomAsync(It.IsAny <Guid>())).Returns(Task.FromResult <Lib.Room>(new Lib.Room()));
var controller = new ComplexController(mockRepo.Object, mockLogger.Object);;
//act
var roomTest = new Lib.Room();
//Need to set lease or else we will get an Argument Exception instead of InvalidOperation Exception
roomTest.SetLease(DateTime.Now, DateTime.Now.AddDays(3));
var result = await controller.PutRoomAsync(Guid.NewGuid(), roomTest);
//assert
Assert.IsType <NotFoundResult>(result);
}
/// <summary>
/// Method that creates a Room
/// </summary>
/// <param name="myRoom"></param>
/// <returns></returns>
public async Task CreateRoomAsync(Lib.Room myRoom)
{
var roomEntity = _map.ParseRoom(myRoom);
roomEntity.Gender = null;
roomEntity.RoomType = await _context.RoomType.FirstAsync(r => r.Type == myRoom.RoomType);
await _context.AddAsync(roomEntity);
await _context.SaveChangesAsync();
}
/// <summary>
/// Method that updates the lease start and end of a Room
/// </summary>
/// <param name="myRoom"></param>
/// <returns></returns>
/// <exception cref="InvalidOperationException">Thrown when room isn't found in DB</exception>
/// <remarks>Update room method for the complex service</remarks>
public async Task UpdateRoomAsync(Lib.Room myRoom)
{
var roomEntity = await _context.Room.Where(r => r.RoomId == myRoom.RoomId)
.Include(r => r.Gender)
.Include(r => r.RoomType)
.FirstAsync();
roomEntity.LeaseStart = myRoom.LeaseStart;
roomEntity.LeaseEnd = myRoom.LeaseEnd;
await _context.SaveChangesAsync();
}
/// <summary>
/// Method that converts a Business Logic Room Object to a DB Entities Room Object
/// Maps RoomId, ComplexId,RoomNumber, NumberOfBeds, LeaseStart, LeaseEnd, NumberOfOccupants
/// </summary>
/// <param name="room"></param>
/// <returns></returns>
/// <remarks>Gender and RoomType are assigned at repo</remarks>
public Entities.Room ParseRoom(Lib.Room room)
{
return(new Entities.Room
{
RoomId = room.RoomId,
ComplexId = room.ComplexId,
RoomNumber = room.RoomNumber,
NumberOfBeds = room.NumberOfBeds,
LeaseStart = room.LeaseStart,
LeaseEnd = room.LeaseEnd,
NumberOfOccupants = room.NumberOfOccupants
});
}
/// <summary>
/// Method that converts a DB Entities Room Object to a Business Logic Library Room Object
/// Maps RoomId, ComplexId, Gender, RoomNumber, RoomType, NumberOfBeds, LeaseStart, LeaseEnd, NumberOfOccupants
/// </summary>
/// <param name="roomEntity"></param>
/// <returns></returns>
public Lib.Room ParseRoom(Entities.Room roomEntity)
{
var room = new Lib.Room()
{
RoomId = roomEntity.RoomId,
ComplexId = roomEntity.ComplexId,
RoomNumber = roomEntity.RoomNumber,
RoomType = roomEntity.RoomType.Type,
NumberOfBeds = roomEntity.NumberOfBeds,
NumberOfOccupants = roomEntity.NumberOfOccupants
};
room.SetLease(roomEntity.LeaseStart, roomEntity.LeaseEnd);
if (roomEntity.Gender != null)
{
room.Gender = roomEntity.Gender.Type;
}
return(room);
}
public async Task PostRoomShouldReturnBadRequest()
{
//arrange
var mockRepo = new Mock <IRepository>();
var mockLogger = new Mock <ILogger <ComplexController> >();
mockRepo.Setup(r => r.CreateRoomAsync(
It.IsAny <Lib.Room>()
)).Throws(new ArgumentException());
var controller = new ComplexController(mockRepo.Object, mockLogger.Object);
//act
var roomTest = new Lib.Room();
var result = await controller.PostRoomAsync(roomTest);
//assert
Assert.IsType <BadRequestResult>(result);
}
