private void HandleAddBookRequest(SendMessage send, AddBookRequest m)
{
if (!IsAdmin(m.Payload.Email))
{
_logger("Did not add book.");
send(new AddBookResponse(false));
return;
}
using (SqlConnection conn = new SqlConnection(_connection))
{
conn.Open();
SqlCommand comm = conn.CreateCommand();
SqlTransaction trans = conn.BeginTransaction();
comm.Connection = conn;
comm.Transaction = trans;
try
{
InitializeAddBookCommand(ref comm, m);
comm.ExecuteNonQuery();
trans.Commit();
_logger("Successfully added book.");
send(new AddBookResponse(true));
}
catch (Exception ex)
{
_logger(ex.ToString());
}
}
}
public Book Map(AddBookRequest request)
{
if (request == null)
{
return(null);
}
var item = new Book
{
Name = request.Name,
Description = request.Description,
LabelName = request.LabelName,
PictureUri = request.PictureUri,
ReleaseDate = request.ReleaseDate,
Format = request.Format,
AvailableStock = request.AvailableStock,
GenreId = request.GenreId,
AuthorId = request.AuthorId,
};
if (request.Price != null)
{
item.Price = new Price
{
Currency = request.Price.Currency,
Amount = request.Price.Amount
};
}
return(item);
}
public async Task <IActionResult> Post(AddBookRequest request)
{
var result = await _bookService.AddBookAsync(request);
return(CreatedAtAction(nameof(GetById), new { id = result.Id },
null));
}
private async Task<Book> MapAddBookRequestToBook(AddBookRequest addBookRequest)
{
List<Genre> genres = new List<Genre>();
foreach (var genreName in addBookRequest.Genres)
{
Genre genre = await _dbContextFactory
.GetContext()
.GetOrCreateGenre(genreName);
genres.Add(genre);
}
BookInfo bookInfo = await _dbContextFactory
.GetContext()
.GetOrCreateBookInfo(addBookRequest.Author, addBookRequest.Title, genres);
Book book = new Book
{
ArriveDate = addBookRequest.ArriveDate,
BookInfoId = bookInfo.Id,
Cost = addBookRequest.Cost
};
return await _dbContextFactory
.GetContext()
.AddBook(book);
}
public async Task AddNew(AddBookRequest addBookRequest)
{
if (string.IsNullOrEmpty(addBookRequest.Title))
{
throw new BadRequestException("Błędna nazwa!!");
}
if (addBookRequest.PagesCount < 1)
{
throw new BadRequestException("Błędna liczba stron!!");
}
if ((await _bookRepository.GetByTitle(addBookRequest.Title)) != null)
{
throw new BadRequestException("Ten tytuł został już użyty!!");
}
if ((await _authorRepository.GetById(addBookRequest.AuthorId)) == null)
{
throw new BadRequestException("Nie ma takiego autora!");
}
Book bookToAdd = new Book
{
Id = Guid.NewGuid(),
Title = addBookRequest.Title,
PagesCount = addBookRequest.PagesCount
};
await _bookRepository.AddNew(bookToAdd);
}
public async Task <BookResponse> AddBookAsync(AddBookRequest request)
{
var item = _bookMapper.Map(request);
var result = _bookRepository.Add(item);
await _bookRepository.UnitOfWork.SaveChangesAsync();
return(_bookMapper.Map(result));
}
public void should_have_error_when_GenreId_is_null()
{
var addBookRequest = new AddBookRequest {
Price = new Price()
};
_validator.ShouldHaveValidationErrorFor(x => x.GenreId, addBookRequest);
}
public async Task <IActionResult> Create([FromForm] AddBookRequest addBookRequest)
{
var result = await Mediator.Send(new CreateBookCommand(addBookRequest.Name, addBookRequest.SureName,
addBookRequest.Title,
addBookRequest.Year, addBookRequest.IsbnType, addBookRequest.IsbnCode,
addBookRequest.CategoryBook, addBookRequest.CategoryName, (addBookRequest.File is not null ? new BookContent(addBookRequest.File.FileName, await addBookRequest.File?.GetBytes()) : null) !));
return(result.IsFailure ? BadRequest(result.Error) : Ok(result.Value));
}
public async Task <Book?> AddBook(AddBookRequest book)
{
var dbBook = _mapper.Map <Data.Dto.Book>(book);
using var context = _contextFactory.CreateDbContext();
context.Books.Add(dbBook);
await context.SaveChangesAsync();
return(await FindBook(dbBook.Id));
}
protected void btnAddBook_Click(object sender, EventArgs e)
{
LibraryService service = ServiceFactory.CreateLibraryService();
AddBookRequest request = new AddBookRequest();
request.ISBN = ddlBookTitles.SelectedValue;
service.AddBook(request);
DisplayBooks();
}
public override Task <AddBookResponse> AddBook(AddBookRequest request, ServerCallContext context)
{
var book = request.Book;
Console.WriteLine("Added book: " + book.Title);
return(Task.FromResult(new AddBookResponse()
{
Status = AddBookResponse.Types.Status.Success
}));
}
private void InitializeAddBookCommand(ref SqlCommand c, AddBookRequest m)
{
c.CommandType = System.Data.CommandType.StoredProcedure;
c.CommandText = "Book.AddBookWithoutInfoID";
SqlParameter title = new SqlParameter("@Title", System.Data.SqlDbType.NVarChar, 128);
title.Direction = System.Data.ParameterDirection.Input;
title.Value = m.Payload.Book.Name;
SqlParameter firstName = new SqlParameter("@AuthorFirstName", System.Data.SqlDbType.NVarChar, 128);
firstName.Direction = System.Data.ParameterDirection.Input;
firstName.Value = m.Payload.Book.Author.FirstName;
SqlParameter lastName = new SqlParameter("@AuthorLastName", System.Data.SqlDbType.NVarChar, 128);
lastName.Direction = System.Data.ParameterDirection.Input;
lastName.Value = m.Payload.Book.Author.LastName;
SqlParameter publisherName = new SqlParameter("@PublisherName", System.Data.SqlDbType.NVarChar, 128);
publisherName.Direction = System.Data.ParameterDirection.Input;
publisherName.Value = m.Payload.Book.Publisher;
SqlParameter genre = new SqlParameter("@GenreDescriptor", System.Data.SqlDbType.NVarChar, 64);
genre.Direction = System.Data.ParameterDirection.Input;
genre.Value = m.Payload.Book.Genre;
SqlParameter ISBN = new SqlParameter("@ISBN", System.Data.SqlDbType.NVarChar, 32);
ISBN.Direction = System.Data.ParameterDirection.Input;
ISBN.Value = m.Payload.Book.ISBN;
SqlParameter copyrightYear = new SqlParameter("@CopyrightYear", System.Data.SqlDbType.SmallInt);
copyrightYear.Direction = System.Data.ParameterDirection.Input;
copyrightYear.Value = m.Payload.Book.CopyrightYear;
SqlParameter bookID = new SqlParameter("@BookID", System.Data.SqlDbType.Int);
bookID.Direction = System.Data.ParameterDirection.Output;
c.Parameters.Add(title);
c.Parameters.Add(firstName);
c.Parameters.Add(lastName);
c.Parameters.Add(publisherName);
c.Parameters.Add(genre);
c.Parameters.Add(ISBN);
c.Parameters.Add(copyrightYear);
c.Parameters.Add(bookID);
}
public async Task add_should_returns_bad_request_if_artistid_not_exist(AddBookRequest request)
{
var client = _factory.CreateClient();
request.AuthorId = Guid.NewGuid();
var httpContent =
new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
var response = await client.PostAsync("/api/books", httpContent);
response.StatusCode.ShouldBe(HttpStatusCode.BadRequest);
}
public async Task add_should_create_new_record(AddBookRequest request)
{
var client = _factory.CreateClient();
var httpContent =
new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
var response = await client.PostAsync("/api/books", httpContent);
response.EnsureSuccessStatusCode();
response.Headers.Location.ShouldNotBeNull();
}
public IHttpActionResult Add(AddBookRequest book)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var addbook = Mapper.Map <Book>(book);
_bookRepository.Add(DatabaseTableNames.Books, addbook);
return(Ok(book));
}
public override async Task <BookModel> AddBook(AddBookRequest request, ServerCallContext context)
{
var book = _mapper.Map <Book>(request.Book);
await _bookContext.Books.AddAsync(book);
await _bookContext.SaveChangesAsync();
_logger.LogInformation("Book successfully added : {bookId}_{bookTitle}", book.BookId, book.Title);
return(_mapper.Map <BookModel>(book));
}
public async Task <BookDto> AddBook(AddBookRequest request)
{
var author = await _repositoryAuthor.GetById(request.AuthorId);
_exceptionAuthor.CheckExistItem(Author, author);
var bookModel = _mapper.Map <Book>(request);
_repositoryBook.Add(bookModel);
return(_mapper.Map <BookDto>(bookModel));
}
public async Task <IActionResult> CreateBook(AddBookRequest request)
{
var command = await _mediator.Send(request);
if (command)
{
await _mediator.Publish(new EmailNotification("*****@*****.**", "A New Book Was Added"));
return(Ok());
}
return(BadRequest());
}
public Book AddBookRequest(AddBookRequest request, [Identity] CoreIdentity originatorReference)
{
var newBook = new Book
{
Id = Guid.NewGuid(),
Title = request.Title,
Author = request.Author,
ReleaseDate = request.ReleaseDate
};
return(StubAdapter.Books.AddBook(newBook));
}
public override Task <AddBookResponse> AddBook(AddBookRequest request, ServerCallContext context)
{
var book = request.Book;
var books = bookOperations.AddBook(book);
_logger.Log(LogLevel.Information, "Added book: " + book.Title);
return(Task.FromResult(new AddBookResponse()
{
Status = AddBookResponse.Types.Status.Success
}));
}
public void should_have_error_when_GenreId_doesnt_exist()
{
_genreServiceMock
.Setup(x => x.GetGenreAsync(It.IsAny <GetGenreRequest>()))
.ReturnsAsync(() => null);
var addBookRequest = new AddBookRequest {
Price = new Price(), GenreId = Guid.NewGuid()
};
_validator.ShouldHaveValidationErrorFor(x => x.GenreId, addBookRequest);
}
public async Task <ActionResult <BookResponse> > Create([FromBody] AddBookRequest request)
{
_logger.Debug($"POST api/v1/books");
var book = new Book(Guid.NewGuid(), request.Title, request.Category);
var addedBook = await _bookService.CreateAsync(book);
if (addedBook == null)
{
return(BadRequest());
}
return(CreatedAtAction(nameof(GetById), new { id = addedBook.Id }, new BookResponse(addedBook, CreateLinks(addedBook.Id))));
}
public async Task It_Adds_Book()
{
using (var httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri("http://localhost:3000");
var request = new AddBookRequest {
Author = "Bob", Title = "My Book"
};
var result = await httpClient.PostAsync("", new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json"));
Assert.True(result.IsSuccessStatusCode);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
}
}
public async override Task <AddBookReply> AddBook(AddBookRequest request, ServerCallContext context)
{
var addBookCommand = new AddBook(request.Title, request.ReleaseDate.ToDateTime());
var addBookResult = await this.mediator
.Send(addBookCommand, cancellationToken : context.CancellationToken);
if (!addBookResult.IsSuccess)
{
throw new RpcException(addBookResult.ToStatus(), addBookResult.Error?.Description);
}
return(new AddBookReply());
}
public async Task <IActionResult> CreateBook(int libraryId, [FromBody] BookView book, CancellationToken token)
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
var request = new AddBookRequest(libraryId, _userHelper.Account?.Id, book.Map());
await _commandProcessor.SendAsync(request, cancellationToken : token);
var renderResult = _bookRenderer.Render(request.Result, libraryId);
return(new CreatedResult(renderResult.Links.Self(), renderResult));
}
public AddBookResponse AddBook(AddBookRequest request)
{
AddBookResponse response = new AddBookResponse();
BookTitle bookTitle = _bookTitleRepository.FindBy(request.ISBN);
Book book = new Book();
book.Id = Guid.NewGuid();
book.Title = bookTitle;
_bookRepository.Add(book);
_unitOfWork.Commit();
response.Success = true;
return(response);
}
public ActionResult <AddBookResponse> AddBook([FromBody] AddBookRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var newBook = request.Book;
bookService.AddBook(ref newBook);
return(Ok(new AddBookResponse {
BookId = newBook.Id
}));
}
public async Task <IActionResult> AddGroupAsync([FromBody] AddBookRequest addGroupAc)
{
var addBook = addGroupAc.AddBook;
var addPublisher = addGroupAc.AddPublisher;
if (string.IsNullOrEmpty(addPublisher.Name.Trim()))
{
return(Ok(new SharedLookUpResponse()
{
HasError = true,
ErrorType = SharedLookUpResponseType.Name,
Message = "Publisher name can't be null or empty"
}));
}
else if (string.IsNullOrEmpty(addPublisher.Email.Trim()))
{
return(Ok(new SharedLookUpResponse()
{
HasError = true,
ErrorType = SharedLookUpResponseType.Name,
Message = "Publisher email can't be null or empty"
}));
}
else if (string.IsNullOrEmpty(addBook.Name.Trim()))
{
return(Ok(new SharedLookUpResponse()
{
HasError = true,
ErrorType = SharedLookUpResponseType.Name,
Message = "Component Group name can't be null or empty"
}));
}
else if (string.IsNullOrEmpty(addBook.Code.Trim()))
{
return(Ok(new SharedLookUpResponse()
{
HasError = true,
ErrorType = SharedLookUpResponseType.Name,
Message = "Component Group code can't be null or empty"
}));
}
else
{
var publisherId = await publisherManagementRepository.AddPublisherAsync(addPublisher);
return(Ok(await bookManagementRepository.AddBookAsync(addBook, publisherId, await GetUserCurrentSelectedInstituteIdAsync())));
}
}
public async Task <IActionResult> AddBook(AddBookRequest request)
{
//ADD LONG BLOB FOR IMAGESSSSSSS
// DON'T FORGET THAT we need to add long blobs
var book_new = new Book(request.Isbn, request.Name, request.Author, request.Genre, request.ReleaseDate, request.Publisher);
_context.Books.Add(book_new);
_context.SaveChanges();
var new_waitlist = new Waitlist(request.Isbn);
_context.Waitlists.Add(new_waitlist);
_context.SaveChanges();
return(Ok());
}
public async Task <Result> Handle(AddBook request, CancellationToken cancellationToken)
{
if (request is null)
{
return(Result.Failure(new ErrorResult(ErrorCode.InvalidArgument, $"{nameof(request)} is null")));
}
var addBookRequest = new AddBookRequest
{
Title = request.Title,
ReleaseDate = Timestamp.FromDateTime(request.ReleaseDate),
};
await this.bookServiceClient
.AddBookAsync(addBookRequest, cancellationToken : cancellationToken);
return(Result.Success());
}
