public async Task <MessageResponse <ReturnBookResponse> > Handle(ReturnBookRequest request, CancellationToken cancellationToken)
{
try
{
var borrowData = await _userBookRepository.IdExists(request.BorrowId)
? await _userBookRepository.GetByIdAsync(request.BorrowId)
: null;
if (!Validate(request, borrowData))
{
return(new MessageResponse <ReturnBookResponse>(MessageType.Validation, new MessageResponseError("Validate", Errors.First())));
}
var book = await _bookRepository.GetById(borrowData.BookId);
book.AvailableCopies++;
await _bookRepository.Update(book);
await _userBookRepository.DeleteAsync(borrowData);
return(new MessageResponse <ReturnBookResponse>(new ReturnBookResponse()));
}
catch (Exception e)
{
return(new MessageResponse <ReturnBookResponse>(MessageType.Error, e));
}
}
public ReturnBookResponse ReturnBook(ReturnBookRequest request)
{
request.Validate();
using (var connection = _DbConnectionProvider.SafelyInvoke(_logger))
{
var book = connection.GetBookById(request.BookId);
if (book == null)
{
throw BookstoreException.BookNotFound;
}
if (book.Status.Equals("Unvailable"))
{
throw BookstoreException.BookIsUnvailable;
}
if (book.Status.Equals("Available"))
{
throw BookstoreException.BookIsAvailable;
}
var newStatus = "Available";
connection.UpdateBookStatus(request.BookId, newStatus);
var newBook = connection.GetBookById(request.BookId);
var updatedBooksDetails = newBook.ToDetailsModel();
return(new ReturnBookResponse
{
BookDetails = updatedBooksDetails
});
}
}
public ReturnBookResponse ReturnBook(ReturnBookRequest request)
{
ReturnBookResponse response = new ReturnBookResponse();
_loanService.Return(new Guid(request.CopyId));
return(response);
}
private void ReturnBook(Guid copyId)
{
LibraryService service = ServiceFactory.CreateLibraryService();
ReturnBookRequest request = new ReturnBookRequest();
request.CopyId = copyId.ToString();
service.ReturnBook(request);
}
internal static void Validate(this ReturnBookRequest request)
{
if (request == null)
{
throw BookstoreException.InvalidJsonData;
}
if (!Guid.TryParse(request.BookId, out Guid bookIdAsGuid))
{
throw BookstoreException.InvalidBookId;
}
}
public async Task <IActionResult> ReturnBooksAsync([FromBody] ReturnBookRequest request)
{
for (var i = 0; i < request.ReturnBookList.Count; i++)
{
await bookManagementRepository.ReturnBookAsync(request.BookId);
var x = request.ReturnBookList[i];
await issueBookManagementRepository.ReturnIssueBookAsync(x.IssueBookId, x.Fine, x.ReturnDate);
}
return(Ok(new { HasError = false, Message = "Return book success!" }));
}
private bool Validate(ReturnBookRequest request, UserBook borrowData)
{
if (borrowData == null)
{
Errors.Add($"The requested borrow with id '{request.BorrowId}' not found!");
}
else if (!request.UserId.Equals(borrowData.UserId))
{
Errors.Add($"The book with id '{borrowData.BookId}'is not borrowed by the user!");
}
return(Errors.Count == 0);
}
public async Task <IActionResult> Return(int bookId)
{
LibraryServiceSoapClient.EndpointConfiguration endpointConfiguration = LibraryServiceSoapClient.EndpointConfiguration.LibraryServiceSoap;
var client = new LibraryServiceSoapClient(endpointConfiguration);
var request = new ReturnBookRequest();
request.Body = new ReturnBookRequestBody(defaultToken, bookId);
var result = await client.ReturnBookAsync(defaultToken, bookId);
if (result.Body.ReturnBookResult == false)
{
return(View("Error"));
}
return(Redirect("AllBooks"));
}
