public async Task <IActionResult> Post([FromBody] Author author) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await _authorRepository.AddAsync(author); return(Ok(author)); }
public async Task <IActionResult> Post([FromBody] Author author) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await _authorRepository.AddAsync(author); return(CreatedAtRoute("GetAuthor", new { Id = author.Id }, author)); }
public async Task RegisterAsync(Guid authorId, string firstName, string lastName, string description, string imageUrl, DateTime?dateOfBirth, DateTime?dateOfDeath, string birthPlace, string authorWebsite, string authorSource, Guid userId) { var author = await _authorRepository.GetByIdAsync(authorId); if (author != null) { throw new ServiceException(ErrorCodes.AuthorAlreadyExist, $"Author with id '{authorId}' already exist."); } try { var authorImage = imageUrl.DefaultAuthorImageNotEmpty(); author = new Author(authorId, firstName, lastName, description, authorImage, dateOfBirth, dateOfDeath, birthPlace, authorWebsite, authorSource, userId); } catch (DomainException ex) { throw new ServiceException(ex, ErrorCodes.InvalidInput, ex.Message); } await _authorRepository.AddAsync(author); }
public async Task <AuthorViewModel> AddAsync(AuthorInputModel authorInputModel) { var author = mapper.Map <Author>(authorInputModel); var result = await repository.AddAsync(author); var authorViewModel = mapper.Map <AuthorViewModel>(result); return(authorViewModel); }
//[ValidationAspect(Validator = typeof(CreateAuthorValidator),AspectPriority = 1)] public async Task <IResult> Handle(CreateAuthorCommand request, CancellationToken cancellationToken) { var author = _mapper.Map <Author>(request); var result = await _authorRepository.AddAsync(author); if (!result.Success) { return(new ErrorResult(result.Message)); } return(new SuccessResult(result.Message)); }
public async Task <ActionResult <AuthorApiModel> > Create([FromBody] Author author) { if (!ModelState.IsValid) { return(BadRequest()); } var newAuthor = await _authorRepository.AddAsync(author); return(CreatedAtAction(nameof(Create), AuthorToApiModel(newAuthor))); }
public async Task AddAsync(AuthorModel item) { if (string.IsNullOrEmpty(item.Name)) { throw new UserException(HttpStatusCode.BadRequest, new List <string> { ExceptionsInfo.InvalidName }); } await _authorRepository.AddAsync(_authorMapper.Map(item)); }
public async Task SaveAsync(AuthorEdit authorEdit) { Author author = authorEdit.Id == null ? new Author() : await authorRepository.GetEntityAsync(authorEdit.Id.Value, true); mapper.Map(authorEdit, author); if (authorEdit.Id == null) { await authorRepository.AddAsync(author); } await authorRepository.SaveChangesAsync(); }
public async Task <AuthorDto> AddNewAuthorAsync(CreateAuthorDto newAuthor) { if (string.IsNullOrEmpty(newAuthor.Email)) { throw new Exception("Author can not have empty email."); } var author = _mapper.Map <Author>(newAuthor); var result = await _authorRepository.AddAsync(author); return(_mapper.Map <AuthorDto>(result)); }
private async Task CreateNewAuthor(CreateBookCommand request) { var names = request.AuthorName.Split(' '); var firstName = names[0]; var lastName = names[1]; CreateAuthorCommand createAuthorCommand = new CreateAuthorCommand() { FirstName = firstName, LastName = lastName }; await _authorRepository.AddAsync(_mapper.Map <Author>(createAuthorCommand)); }
public async Task <string> SaveAsync(Author author) { try { await _authorRepository.AddAsync(author); await _unitOfWork.CompleteAsync(); return(MessageConstants.Saved);; } catch (Exception ex) { // Do some logging stuff return($"{MessageConstants.SavedWarning}: {ex.Message}");; } }
public async Task <Result <Author> > CreateAuthor(Author newAuthor) { var validationResult = await _authorValidator.ValidateAsync(newAuthor); if (!validationResult.IsValid) { return(Result.Failure(newAuthor, validationResult.Errors.Select(s => s.ErrorMessage).ToList())); } var createdAuthor = await _authorRepository.AddAsync(newAuthor); return(Result.Success(createdAuthor)); }
public async Task <ActionResult <Author> > CreateAuthor(AuthorCreateDto author) { if (author == null) { return(BadRequest()); } var authorEntity = _mapper.Map <Author>(author); var returnedEntity = await _authorRepository.AddAsync(authorEntity); return(CreatedAtRoute("GetAuthor", new { authorId = returnedEntity.Id }, returnedEntity)); }
public async Task <IdResponse> CreateAuthorAsync(AuthorProxy author) { Validate(author); await ValidateUniqueness(author.FirstName, author.LastName, null); var entity = new Author(); MapToEntity(author, entity); var id = await _repository.AddAsync(entity); return(new IdResponse(id)); }
public async Task <AuthorSaveResponse> SaveAsync(Author author) { try { await _authorRepository.AddAsync(author); await _transaction.CompleteAsync(); return(new AuthorSaveResponse(author)); } catch (Exception ex) { return(new AuthorSaveResponse($"An error occurred while attempting to save the author: {ex.Message}")); } }
public async Task <AuthorResponse> SaveAsync(Author Author) { try { await authorRepository.AddAsync(Author); await unitOfWork.CompleteAsync(); return(new AuthorResponse(Author)); } catch (Exception ex) { return(new AuthorResponse($"Error when saving the Author: {ex.Message}")); } }
public async Task <AuthorModel> Handle(CreateAuthorCommand request, CancellationToken cancellationToken) { IList <Book> books = new List <Book>(); if (request.BookIds != null && request.BookIds.Any()) { books = await bookRepository.FindWhereInAsync(request.BookIds); } var author = new Author(request.Name, books); await authorRepository.AddAsync(author); await authorRepository.UnitOfWork.SaveChangesAsync(cancellationToken); return(mapper.MapEntityToModel <Author, AuthorModel>(author)); }
public async Task <IActionResult> Create(Author newAuthor, IFormCollection collection) { try { if (!ModelState.IsValid) { return(View(newAuthor)); } await _authorRepository.AddAsync(newAuthor); return(RedirectToAction(nameof(Index))); } catch (Exception ex) { Console.WriteLine(ex.Message); } return(View(newAuthor)); }
public async Task <AuthorResponse> SaveAsync(Author author) { try { await _authorRepository.AddAsync(author); await _unitOfWork.CompleteAsync(); author = await _authorRepository.FindByIdAsync(author.Id); return(new AuthorResponse(author)); } catch (Exception e) { _logger.LogError(e.ToString()); return(new AuthorResponse("An error ocurred while saving the Author: " + $"{e.Message} {e.InnerException?.Message}")); } }
public async Task <MContentResult <AuthorDto> > AddAsync(AuthorDto authorDto) { //Validate var validationResult = await _validationService.ValidateAdd(authorDto); if (!validationResult.IsValid) { return(validationResult.ConvertFromValidationResult <AuthorDto>()); } //Map to domain object var entityForDb = _mapper.Map <Author>(authorDto); var addedEntity = await _repository.AddAsync(entityForDb); //Map to dto var resultEntity = _mapper.Map <AuthorDto>(addedEntity); ResultDto.Data = resultEntity; ResultDto.StatusCode = (int)StatusCodes.Created; return(ResultDto); }
public async Task <AuthorModel> AddAsync(AuthorModel model) { if (model is null) { throw new ServerException(HttpStatusCode.BadRequest, ExceptionMessage.EMPTY_AUTHOR); } if (await _repository.ExistsAsync(model.Id)) { throw new ServerException(HttpStatusCode.BadRequest, ExceptionMessage.AUTHOR_ALREADY_EXISTS); } var author = _mapper.Map <Author>(model); await _repository.AddAsync(author); var mapped = _mapper.Map <AuthorModel>(author); return(mapped); }
/// <summary> /// Create a new author. /// </summary> /// <param name="author"></param> /// <returns></returns> public async Task <Result <AuthorInfo> > AddAsync(AuthorInfo author) { var authorDb = _mapper.Map <AuthorInfo, AuthorDb>(author); try { await _authorRepository.AddAsync(authorDb); return(Result <AuthorInfo> .Ok(_mapper.Map <AuthorInfo>(authorDb))); } catch (DbUpdateConcurrencyException e) { return((Result <AuthorInfo>) Result <AuthorInfo> .Fail($"Cannot save author. {e.Message}")); } catch (DbUpdateException e) { return((Result <AuthorInfo>) Result <AuthorInfo> .Fail($"Cannot save author. Duplicate field. {e.Message}")); } catch (DbEntityValidationException e) { return((Result <AuthorInfo>) Result <AuthorInfo> .Fail($"Invalid user. {e.Message}")); } }
public async Task <BookResponse> SaveAsync(Book book) { try { if (!string.IsNullOrEmpty(book.Genre.Name)) { var genre = await genreRepository.FindByKeyFieldsAsync(book.Genre.Name); if (genre == null) { await genreRepository.AddAsync(book.Genre); book.GenreId = book.Genre.Id; } else { book.GenreId = genre.Id; } } if (!string.IsNullOrEmpty(book.Publisher.Name)) { var publisher = await publisherRepository.FindByKeyFieldsAsync(book.Publisher.Name, book.Publisher.City); if (publisher == null) { await publisherRepository.AddAsync(book.Publisher); book.PublisherId = book.Publisher.Id; } else { book.PublisherId = publisher.Id; } } foreach (var author in book.Authors) { var authorInBase = await authorRepository.FindByKeyFieldsAsync(author.Author.LastName, author.Author.FirstName, author.Author.Patronymic); if (authorInBase == null) { await authorRepository.AddAsync(author.Author); author.AuthorId = author.Author.Id; } else { author.AuthorId = authorInBase.Id; } } await bookRepository.AddAsync(book); await unitOfWork.CompleteAsync(); return(new BookResponse(book)); } catch (Exception ex) { return(new BookResponse($"Error when saving the book: {ex.Message}")); } }
public async Task CreateAuthorAsync(Author author) { await _authorRepository.AddAsync(author); await _unitOfWork.CompleteAsync(); }
public async Task AddAuthorAsync(Author newAuthor) { await _authorRepository.AddAsync(newAuthor); }
public async Task <Author> Handle(CreateAuthorCommand request, CancellationToken cancellationToken) { return(await authorRepository.AddAsync(request.Author)); }
public async Task AddAuthorAsync(AuthorDTO authorDTO) { await _authorRepository.AddAsync(new Author(authorDTO.Firstname, authorDTO.Surname)); }
public async Task <IActionResult> Post([FromBody] Author author) { await _authorRepository.AddAsync(author); return(Ok(author)); }