public void ReturnBookFromUser(Guid userAggregateRootId, Guid bookAggregateRootId)
{
ReturnBookCommand command = new ReturnBookCommand
{
UserAggregateRootId = userAggregateRootId,
BookAggregateRootId = bookAggregateRootId
};
CommitCommand(command);
}
public void ReturnBookFromUser(long bookId, long userAccountId)
{
ReturnBookCommand command = new ReturnBookCommand
{
BookAggregateRootId = bookId,
UserAccountAggregateRootId = userAccountId
};
this.CommitCommand(command);
}
public Guid Return(Guid customerId, Guid bookId)
{
var command = new ReturnBookCommand
{
BookId = bookId,
CustomerId = customerId
};
_commandPublisher.Publish(command);
return(command.CommandUniqueId);
}
public void HandleCommand(ReturnBookCommand command)
{
User user = DomainRepository.Get <User>(command.UserAggregateRootId);
Book book = DomainRepository.Get <Book>(command.BookAggregateRootId);
user.ReturnBook(book);
book.ReceiveStock(1);
DomainRepository.Save(user);
DomainRepository.Save(book);
DomainRepository.Commit();
}
public bool Handle(ReturnBookCommand message)
{
using (IDomainRepository domainRepository = this.GetDomainRepository())
{
UserAccount user = domainRepository.Get <UserAccount>(message.UserAccountAggregateRootId);
Book book = domainRepository.Get <Book>(message.BookAggregateRootId);
IUserAccountBookTransferService bookTransService = this.GetBookTransferService();
bookTransService.ReturnBookFromUser(user, book);
domainRepository.Save(user);
domainRepository.Save(book);
domainRepository.Commit();
return(domainRepository.Committed);
}
}
public async void HandleReturnBookCommand_WithInvalidGuid_ShouldReturnInvalidLoanGuid(string loanId, string outputError)
{
//Arrange
ReturnBookCommand returnBookCommand = new ReturnBookCommand(loanId);
var sut = Mocker.CreateInstance <ReturnBookCommandHandler>();
//Act
ReturnBookCommandResponseViewModel result = await sut.Handle(returnBookCommand, new CancellationToken());
//Assert
DomainNotifications.GetAll().Should().NotBeNullOrEmpty()
.And.Contain(x => x == outputError);
Mocker.GetMock <IBookLoanRepository>().Verify(x => x.Update(It.IsAny <BookLoan>()), Times.Never());
}
public async Task Return_Book()
{
using (var context = GetContextWithData())
{
var handler = new ReturnBookCommandHandler(context);
var command = new ReturnBookCommand
{
Id = context.Books.First().Id
};
var returnedBook = await handler.Handle(command, CancellationToken.None);
Assert.Null(returnedBook.Lender);
}
}
public async void HandleReturnBookCommand_WithInvalidLoan_ShouldReturnInvalidLoan()
{
//Arrange
ReturnBookCommand returnBookCommand = new ReturnBookCommand(Guid.NewGuid().ToString());
var sut = Mocker.CreateInstance <ReturnBookCommandHandler>();
Mocker.GetMock <IBookLoanRepository>()
.Setup(p => p.GetByLoanId(It.IsAny <Guid>(), It.IsAny <bool>()))
.Returns(() => Task.FromResult <BookLoan>(null));
//Act
ReturnBookCommandResponseViewModel result = await sut.Handle(returnBookCommand, new CancellationToken());
//Assert
DomainNotifications.GetAll().Should().NotBeNullOrEmpty()
.And.Contain(x => x == "Book loan not found");
Mocker.GetMock <IBookLoanRepository>().Verify(x => x.Update(It.IsAny <BookLoan>()), Times.Never());
}
public async void HandleReturnBookCommand_WithValidInfos_ShouldReturnNoErrors()
{
//Arrange
ReturnBookCommand returnBookCommand = new ReturnBookCommand(Guid.NewGuid().ToString());
var sut = Mocker.CreateInstance <ReturnBookCommandHandler>();
BookLoan bookLoan = BookLoanFactory.ReturnLoan();
bookLoan.Book.WithBookSituation(BookSituationEnum.Lent);
Mocker.GetMock <IBookLoanRepository>()
.Setup(p => p.GetByLoanId(It.IsAny <Guid>(), It.IsAny <bool>()))
.Returns(() => Task.FromResult <BookLoan>(bookLoan));
//Act
ReturnBookCommandResponseViewModel result = await sut.Handle(returnBookCommand, new CancellationToken());
//Assert
DomainNotifications.GetAll().Should().BeEmpty();
Mocker.GetMock <IBookLoanRepository>().Verify(x => x.Update(It.IsAny <BookLoan>()), Times.Once());
}
public async Task <IActionResult> ReturnBook([FromBody] ReturnBookCommand command)
{
RequestResult requestResult = await _orquestrator.SendCommand(command);
return(await ReturnRequestResult(requestResult));
}
public async Task <IActionResult> ReturnBook(ReturnBookCommand command)
{
var result = await _mediator.Send(command, new System.Threading.CancellationToken());
return(await ReturnCommand(result));
}
public ReturningBook(ReturnBookCommand command) => Command = command;
