public async Task <CreateBookCommandResult> Handle(CreateBookManualCommand request, CancellationToken cancellationToken)
{
var categories = await _categoryRepository.GetAllByIdAsync(request.CategoriesIds);
if (!categories.Any())
{
return(new CreateBookCommandResult(false, new[] { "Requested category/s not found" }));
}
var authors = await _authorRepository.GetAllByIdAsync(request.AuthorsIds);
if (!authors.Any())
{
return(new CreateBookCommandResult(false, new[] { "Requested category/s not found" }));
}
var book = new Domain.Book(request.Title,
request.Description, request.Isbn10,
request.Isbn13, request.LanguageId,
request.PublisherId, request.PageCount,
request.Visibility, request.PublishedDate);
foreach (var category in categories)
{
book.AddCategory(category);
}
foreach (var author in authors)
{
book.AddAuthor(author);
}
var result = _bookRepository.Add(book);
if (await _bookRepository.UnitOfWork.SaveChangesAsync(cancellationToken) < 1)
{
return(new CreateBookCommandResult(false, new[] { "Error occured during saving Book" }));
}
var bookResult = _mapper.Map <CommandBookDto>(result);
var bookResultEvent = _mapper.Map <CreateBook>(result);
bookResultEvent.Language = result.LanguageId > 0
? _mapper.Map <LanguageDto>(await _languageRepository.FindByIdAsync(result.LanguageId ?? 0))
: null;
bookResultEvent.Publisher = result.LanguageId > 0
? _mapper.Map <PublisherDto>(await _publisherRepository.FindByIdAsync(result.PublisherId ?? 0))
: null;
var endpoint = await _sendEndpointProvider.GetSendEndpoint(new Uri($"queue:{EventBusConstants.CreateBookQueue}"));
await endpoint.Send(bookResultEvent, cancellationToken);
return(new CreateBookCommandResult(true, bookResult));
}
public CreateBookManualCommandValidator(IAuthorRepository authorRepository,
ICategoryRepository categoryRepository,
ILanguageRepository languageRepository,
IPublisherRepository publisherRepository)
{
_authorRepository = authorRepository;
_categoryRepository = categoryRepository;
_languageRepository = languageRepository;
_publisherRepository = publisherRepository;
RuleFor(b => b.Title)
.MinimumLength(3)
.MaximumLength(100);
RuleFor(b => b.Description)
.MinimumLength(3)
.MaximumLength(5000);
RuleFor(b => b.Isbn10)
.Length(10)
.Matches("^[0-9]+$").WithMessage("ISBN10 Field must contain only digits");
RuleFor(b => b.Isbn13)
.Length(13)
.Matches("^[0-9]+$").WithMessage("ISBN13 Field must contain only digits");
RuleFor(b => b.PageCount)
.GreaterThanOrEqualTo((ushort)1);
const int authorIdMinValue = 1;
RuleFor(b => b.AuthorsIds)
.NotEmpty()
.ForEach(a =>
a.GreaterThanOrEqualTo(authorIdMinValue)
.WithMessage($"Author id must be greater then {authorIdMinValue - 1}"))
.AllValuesMustExistsInDb(nameof(Author.Id), _authorRepository.GetAllAsync());
RuleFor(b => b.LanguageId)
.GreaterThanOrEqualTo(1)
.ValueMustExistsInDb(id => _languageRepository.FindByIdAsync(id ?? 0));
RuleFor(b => b.PublisherId)
.GreaterThanOrEqualTo(1)
.ValueMustExistsInDb(id => _publisherRepository.FindByIdAsync(id ?? 0));
const int categoryIdMinValue = 1;
RuleFor(b => b.CategoriesIds)
.ForEach(c =>
c.GreaterThanOrEqualTo(categoryIdMinValue)
.WithMessage($"Category id must be greater than {categoryIdMinValue - 1}"))
.AllValuesMustExistsInDb(nameof(Category.Id), _categoryRepository.GetAllAsync());
}
public async Task <LanguageDto> Handle(FindLanguageByIdQuery request, CancellationToken cancellationToken)
{
var language = await _languageRepository.FindByIdAsync(request.Id);
return(language is not null
? new LanguageDto()
{
Id = language.Id,
Name = language.Name
} : null);
}
public async Task <Language> FindByIdAsync(int id)
{
_logger.LogInfoCreateMethodStarted <Language>(LanguageRepositoryType, nameof(FindByIdAsync), new object[] { id });
var result = await _languageRepository.FindByIdAsync(id);
if (result is null)
{
_logger.LogWarningNotFound <Language>(LanguageRepositoryType, nameof(FindByIdAsync), new object[] { id });
}
_logger.LogInfoMethodEnded(LanguageRepositoryType, nameof(FindByIdAsync), result);
return(result);
}
