public async Task <IActionResult> UpdateBookAsync([FromBody] UpdateBookRequest updateComponentGroupAc)
{
var updatePublisher = updateComponentGroupAc.UpdatePublisher;
var updateBook = updateComponentGroupAc.UpdateBook;
if (string.IsNullOrEmpty(updatePublisher.Name.Trim()))
{
return(Ok(new SharedLookUpResponse()
{
HasError = true,
ErrorType = SharedLookUpResponseType.Name,
Message = "Publisher name can't be null or empty"
}));
}
else if (string.IsNullOrEmpty(updatePublisher.Email.Trim()))
{
return(Ok(new SharedLookUpResponse()
{
HasError = true,
ErrorType = SharedLookUpResponseType.Name,
Message = "Publisher name can't be null or empty"
}));
}
else if (string.IsNullOrEmpty(updateBook.Name.Trim()))
{
return(Ok(new SharedLookUpResponse()
{
HasError = true,
ErrorType = SharedLookUpResponseType.Name,
Message = "Book name can't be null or empty"
}));
}
else if (string.IsNullOrEmpty(updateBook.Code.Trim()))
{
return(Ok(new SharedLookUpResponse()
{
HasError = true,
ErrorType = SharedLookUpResponseType.Name,
Message = "Book code can't be null or empty"
}));
}
else
{
var instituteId = await GetUserCurrentSelectedInstituteIdAsync();
await publisherManagementRepository.UpdatePublisherAsync(updatePublisher);
if (await iMSDbContext.Books.AnyAsync(x => x.Id == updateBook.Id && x.InstituteId == instituteId))
{
return(Ok(await bookManagementRepository.UpdateBookAsync(updateBook, instituteId)));
}
else
{
return(Ok(new SharedLookUpResponse()
{
HasError = true, ErrorType = SharedLookUpResponseType.Code, Message = "Book not found"
}));
}
}
}
public async Task <BaseResponse <bool> > Handle(UpdateBookRequest request, CancellationToken cancellationToken)
{
BaseResponse <Boolean> response = new BaseResponse <bool>();
try
{
var book = await _repository.GetBookById(request.Id);
if (book == null)
{
response.Errors.Add("Böyle bir kitap bulunamadı.");
response.Data = false;
}
else
{
book.Name = request.Name;
book.ImageUrl = request.ImageUrl;
book.Description = request.Description;
book.Price = request.Price;
book.CategoryId = request.CategoryId;
await _repository.Update(book);
response.Data = true;
}
}
catch (Exception e)
{
Console.WriteLine(e);
response.Errors.Add(e.Message);
response.Data = false;
}
return(response);
}
public async Task <IHttpActionResult> Update([FromUri] int id, [FromBody] UpdateBookRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var category = await _repoWrapper.Category.GetCategoryByName(request.Category);
var book = new IBooks
{
Title = request.Title,
Descriptions = request.Description,
Published = DateTime.Parse(request.Published),
PageCount = request.PageCount,
CategoryId = category.Id
};
var updated = await _repoWrapper.Book.UpdateAsync(id, book);
if (updated)
{
return(Ok());
}
return(NotFound());
}
public static Book ConvertToBook(this UpdateBookRequest updateRequest)
{
Book book = new Book();
book.BookId = updateRequest.BookId;
book.Title = updateRequest.Title;
book.ISBN = updateRequest.ISBN;
book.Description = updateRequest.Description;
book.Genre = new Genre()
{
GenreId = updateRequest.GenreId
};
book.Language = new Language()
{
LanguageId = updateRequest.LanguageId
};
book.Authors = new List <Author>();
foreach (int id in updateRequest.AuthorIds)
{
book.Authors.Add(new Author()
{
AuthorId = id
});
}
return(book);
}
public async Task <BaseResponse <bool> > Handle(UpdateBookRequest request, CancellationToken cancellationToken)
{
BaseResponse <Boolean> response = new BaseResponse <bool>();
try
{
var book = (await _repository.SearchAsyncWithBookId <Book, int>(request.Id))
.FirstOrDefault(p => p.Id == request.Id);
if (book != null)
{
book.Name = request.Name;
book.ImageUrl = request.ImageUrl;
book.Description = request.Description;
book.Price = request.Price;
book.CategoryId = request.CategoryId;
response.Data = await _repository.UpdateAsync <Book, int>(book);
}
else
{
response.Data = false;
}
}
catch (Exception e)
{
response.Data = false;
Console.WriteLine(e);
throw;
}
return(response);
}
public async Task <IActionResult> UpdateAsync([FromRoute] int BookId, [FromBody] UpdateBookRequest updateBookRequest)
{
var book = await this.bookService.GetBookByIdAsync(BookId);
book.Title = updateBookRequest.Title;
book.Description = updateBookRequest.Description;
book.Price = Convert.ToDecimal(updateBookRequest.Price, new System.Globalization.CultureInfo("en-US"));
book.Language = await this.languageService.GetLanguageByTitleAsync(updateBookRequest.Language.Title);
book.BookAuthors = updateBookRequest.BookAuthors.Select(x => new BookAuthor {
Author = this.authorService.GetAuthorById(x.Id), Book = book
}).ToList();
book.BookCategories = updateBookRequest.BookCategories.Select(x => new BookCategory {
Category = this.categoryService.GetCategoryById(x.Id), Book = book
}).ToList();
var updated = await this.bookService.UpdateBookAsync(book);
if (!updated)
{
return(this.NotFound());
}
return(this.Ok(book));
}
public async Task <IActionResult> PutBook(int id, UpdateBookRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var book = new Book
{
Id = id,
Name = request.Name,
CatalogId = request.CatalogId
};
_context.Entry(book).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BookExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> UpdateBook(UpdateBookRequest data)
{
_logger.LogInformation($"Update Book");
var book = _mapper.Map <Book>(data);
await _bookService.UpdateBookAsync(book);
return(Ok());
}
public async Task <IActionResult> UpdateBook([FromBody] UpdateBookRequest request)
{
Book book = await _bookService.GetById(request.Id);
book.Name = request.Name;
book.AuthorId = request.AuthorId;
book.TypeId = request.TypeId;
_bookService.Update(book);
return(Ok());
}
public async Task <IActionResult> SaveDescription(int id, [FromBody] UpdateBookRequest bookRequest)
{
_logger.LogInformation($"Update book description by id {id}");
var book = await _bookService.SaveBookDescriptionAsync(id, bookRequest.Descr);
var bookResponse = _mapper.Map <BookResponse>(book);
return(Ok(bookResponse));
}
public HttpResponseMessage UpdateBooks([FromUri] UpdateBookRequest bookReq)
{
try
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
public async Task <IActionResult> Patch(Guid id, [FromBody] UpdateBookRequest request)
{
if (id == Guid.Empty || !ModelState.IsValid)
{
return(BadRequest());
}
var command = new UpdateBook(request.ToBook(id), UserId);
await Mediator.Send(command);
return(Ok());
}
public void UpdateBook(UpdateBookRequest request)
{
Persistence.BeginTransaction();
if (!new UpdateBookRequestValidator().Validate(request).IsValid)
{
throw new Exception("UpdateBook validation error");
}
var book = GetBookById(request.Id);
book.Update(request);
Persistence.Commit();
}
public async Task <IActionResult> UpdateAsync(int id, UpdateBookRequest request)
{
try
{
var result = await _bookService.UpdateAsync(id, request);
return(Ok(result));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <IActionResult> UpdateBookAsync([FromBody] UpdateBookRequest BookRequest)
{
UpdateBookRequest update = new UpdateBookRequest();
update = BookRequest;
(bool succeed, string message, UpdateBookResponse BookResponse) = await Mediator.Send(update);
if (succeed)
{
return(Ok(BookResponse.ToResponse()));
}
return(BadRequest(message.ToResponse(false, message)));
}
public async Task <ActionResult <BookResponse> > Update([FromRoute] Guid id, [FromBody] UpdateBookRequest request)
{
_logger.Debug($"PUT api/v1/books/{id}");
var book = new Book(request.Title, request.Category);
var updatedBook = await _bookService.UpdateAsync(id, book);
if (updatedBook == null)
{
return(NotFound());
}
return(Ok(new BookResponse(updatedBook, CreateLinks(updatedBook.Id))));
}
public async Task <Response> UpdateABook(UpdateBookRequest book)
{
Response response = new Response();
Book books = new Book()
{
Id = book.Id,
Name = book.Name,
Author = book.Author,
ISBN = book.ISBN
};
var result = await _repositoryCommand.Update(books);
response.Data = result;
return(response);
}
public ActionResult Edit(BookSinglePageViewModel model)
{
UpdateBookRequest request = model.BookViewModel.ConvertToUpdateBookRequest();
UpdateBookResponse response = _bookService.UpdateBook(request);
if (response.Success)
{
return(RedirectToAction("Index"));
}
else
{
model.Success = false;
model.Message = response.Message;
return(View(model));
}
}
public async Task <BookDto> UpdateBook(Guid id, UpdateBookRequest request)
{
var author = await _repositoryAuthor.GetById(request.AuthorId);
_exceptionAuthor.CheckExistItem(Author, author);
var book = await _repositoryBook.GetById(id);
_exceptionBook.CheckExistItem(Book, book);
_mapper.Map(request, book);
_repositoryBook.Update(book);
_repositoryBook.SaveAll();
return(_mapper.Map <BookDto>(book));
}
public UpdateBookResponse UpdateBook(UpdateBookRequest request)
{
UpdateBookResponse response = new UpdateBookResponse();
try
{
Book book = request.ConvertToBook();
_bookRepository.Update(book);
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public async Task Update_ValidObjectPassed_ReturnsUpdatedResponse()
{
//Arrange
var cbr = new UpdateBookRequest
{
Id = _dbContext.Books.FirstOrDefault().Id,
Title = "Art of Unit Testing",
Author = "Roy Osherove",
Price = 100
};
//Act
var actionResult = await _bookController.UpdateAsync(cbr);
//Assert
Assert.IsType <CreatedAtRouteResult>(actionResult);
}
public async Task Update_NotExistingGuidPassed_ReturnsNotFoundResponse()
{
// Arrange
var cbr = new UpdateBookRequest
{
Id = new Guid(),
Title = "Art of Unit Testing",
Author = "Roy Osherove",
Price = 100
};
// Act
var badResponse = await _bookController.UpdateAsync(cbr);
// Assert
Assert.IsType <NotFoundResult>(badResponse);
}
public static UpdateBookRequest ConvertToUpdateBookRequest(this BookViewModel model)
{
UpdateBookRequest request = new UpdateBookRequest();
request.BookId = model.BookId;
request.Title = model.Title;
request.ISBN = model.ISBN;
request.Description = model.Description;
request.GenreId = Convert.ToInt32(model.Genre.GenreId);
request.LanguageId = Convert.ToInt32(model.Language.LanguageId);
request.AuthorIds = new List <int>();
foreach (int id in model.AuthorIds)
{
request.AuthorIds.Add(id);
}
return(request);
}
public async Task <bool> Handle(UpdateBookRequest message, IOutputPort <UpdateBookReponse> outputPort)
{
var existingBook = await _bookRepository.GetById(message.Id);
if (existingBook == null)
{
outputPort.Handle(new UpdateBookReponse(message: $"Book with Id:{message.Id} does not exists"));
return(false);
}
Book book = new Book
{
Id = message.Id,
Name = message.Name,
Text = message.Text,
Price = message.Price
};
await _bookRepository.Update(book, book.Id);
return(true);
}
private async Task<Book> MapUpdateBookRequestToBook(Guid bookGuid, UpdateBookRequest updateBookRequest)
{
var bookShopState = await GetBookShopState();
var book = await _dbContextFactory.GetContext().GetBook(bookGuid);
if (book == null)
{
return null;
}
if (updateBookRequest.Title != book.BookInfo.Title || updateBookRequest.Author != book.BookInfo.Author)
{
List<Genre> genres = new List<Genre>();
if (updateBookRequest.Genres != null)
{
foreach (var genreName in updateBookRequest.Genres)
{
Genre genre = await _dbContextFactory
.GetContext()
.GetOrCreateGenre(genreName);
genres.Add(genre);
}
}
BookInfo bookInfo = await _dbContextFactory
.GetContext()
.GetOrCreateBookInfo(updateBookRequest.Author, updateBookRequest.Title, genres);
book.BookInfoId = bookInfo.Id;
}
book.BookInfo = null;
book.Cost = updateBookRequest.Cost;
book.ArriveDate = updateBookRequest.ArriveDate;
return await _dbContextFactory
.GetContext()
.UpdateBook(book);
}
public async Task <IActionResult> Update([FromRoute] Guid bookId, [FromBody] UpdateBookRequest req)
{
_logger.LogInformation("Requisitando atualização de livro com id {bookId}...", bookId);
_logger.LogInformation("Dados da requisição: {req}",
JsonConvert.SerializeObject(req));
var updatedBook = _mapper.Map <Book>(req);
var result = await _bookService
.UpdateBookAsync(bookId, updatedBook)
.ConfigureAwait(false);
if (!result)
{
_logger.LogWarning("Erro ao tentar atualizar livro. " +
"Aplicação encerrou a requisição com o status {statusCode}",
HttpStatusCode.BadRequest);
return(BadRequest());
}
_logger.LogInformation("Livro com id {id} foi atualizado!", bookId);
return(Ok(_mapper.Map <BookResponse>(updatedBook)));
}
public async Task <UpdateBookResult> UpdateBook(UpdateBookRequest request)
{
try
{
DynamicParameters parameters = new DynamicParameters();
parameters.Add("@BookName", request.BookName);
parameters.Add("@BookId", request.BookId);
parameters.Add("@Author", request.Author);
parameters.Add("@Description", request.Description);
parameters.Add("@Year", request.Year);
parameters.Add("@Amount", request.Amount);
parameters.Add("@CategoryName", request.CategoryName);
return(await SqlMapper.QueryFirstOrDefaultAsync <UpdateBookResult>(cnn : connect,
sql : "sp_UpdateBook",
param : parameters,
commandType : CommandType.StoredProcedure));
}
catch (Exception ex)
{
throw;
}
}
public async Task Update_ValidObjectPassed_ReturnedResponseHasUpdatedItem()
{
// Arrange
var cbr = new UpdateBookRequest
{
Id = _dbContext.Books.FirstOrDefault().Id,
Title = "Art of Unit Testing. Updated!",
Author = "Roy Osherove. Updated!",
Price = 999
};
// Act
var createdResponse = await _bookController.UpdateAsync(cbr) as CreatedAtRouteResult;
var item = createdResponse.Value as BookResponse;
// Assert
Assert.IsType <BookResponse>(item);
Assert.Equal("Art of Unit Testing. Updated!", item.Title);
Assert.Equal("Roy Osherove. Updated!", item.Author);
Assert.Equal(999, item.Price);
}
public async Task <UpdateBookResponse> UpdateAsync(int id, UpdateBookRequest request)
{
try
{
var exist = await _unitOfWork.BookRepository.FirstOfDefaultAsync(s => s.Id == id);
var existCategory = await _unitOfWork.CategoryRepository.FirstOfDefaultAsync(s => s.Id == request.CategoryId);
if (existCategory == null)
{
throw new Exception("BookCategory does not exist");
}
if (exist == null)
{
throw new Exception("Data not found");
}
exist.Name = request.BookName;
exist.BookCategory = existCategory;
_unitOfWork.BookRepository.Update(exist);
if (await _unitOfWork.CommitAsync())
{
return(new UpdateBookResponse()
{
CategoryId = exist.Id,
CategoryName = exist.Name
});
}
throw new Exception("Data invalid");
}
catch (Exception ex)
{
throw;
}
}
public async Task update_book_validation_failed(
Guid bookId,
int newYear,
string newTitle,
Guid newAuthorId,
Guid newGenreId
)
{
var request = new UpdateBookRequest
{
BookId = bookId,
NewTitle = newTitle,
NewAuthorId = newAuthorId,
NewGenreId = newGenreId,
NewYear = newYear
};
var validator = new UpdateBookRequestValidator();
var validationResult = await validator.ValidateAsync(request);
Assert.False(validationResult.IsValid);
}
