public void property_update_succeeds()
{
var sut = new AuthorUpdateDto()
{
Id = 7,
FirstName = "Unit",
LastName = "Test",
PhoneNumber = "303-333-4455",
Address = "12345 Unit Test",
City = "Denver",
State = "CO",
ZipCode = "80014"
};
using (new AssertionScope())
{
sut.FirstName.Should().Be("Unit");
sut.LastName.Should().Be("Test");
sut.Id.Should().Be(7);
sut.PhoneNumber.Should().Be("303-333-4455");
sut.Address.Should().Be("12345 Unit Test");
sut.City.Should().Be("Denver");
sut.State.Should().Be("CO");
sut.ZipCode.Should().Be("80014");
}
}
public async Task <IActionResult> Put(Guid id, [FromBody] AuthorUpdateDto author)
{
if (id == Guid.Empty)
{
return(BadRequest(GetMessageObject(InvalidIdentifier)));
}
if (!ModelState.IsValid)
{
LogModelStateErrors(_logger);
return(ValidationProblem(ModelState));
}
try
{
await _authorService.UpdateAuthor(id, author);
return(NoContent());
}
catch (AuthorNotFoundException exception)
{
_logger.LogError($"Error occurred: {exception.GetMessageWithStackTrace()}");
return(NotFound($"Author with id: {id} not found."));
}
catch (Exception exception)
{
_logger.LogError($"Error occurred: {exception.GetMessageWithStackTrace()}");
return(InternalServerErrorResult($"Error occurred updating author with id: {id}"));
}
}
public async Task <ActionResult <Author> > UpdateAuthor(int authorId, [FromBody] AuthorUpdateDto authorUpdate)
{
if (authorUpdate == null)
{
return(BadRequest());
}
if (authorId != authorUpdate.Id)
{
return(BadRequest("The AuthorId parameter does not match the AuthorId in the request body."));
}
var existingAuthor = await _authorRepository.GetAuthorAsync(authorId);
if (existingAuthor == null)
{
return(NotFound());
}
_mapper.Map(authorUpdate, existingAuthor);
await _authorRepository.UpdateAsync(existingAuthor);
_logger.LogInformation($"The author id:: {authorId} has been updated.");
return(Ok(existingAuthor));
}
public async Task update_author_succeeds()
{
var author = new Author()
{
Id = 99, AuthorCode = "111-22-3333", FirstName = "A", LastName = "B", PhoneNumber = "1", Contract = false
};
var authorUpdated = new Author()
{
Id = 99, AuthorCode = "111-22-3333", FirstName = "Unit", LastName = "Test", PhoneNumber = "1", Contract = false
};
var authorDto = new AuthorUpdateDto()
{
Id = 99, FirstName = "Unit", LastName = "Test", PhoneNumber = "1"
};
_mockAuthorRepository.Setup(s => s.GetAuthorAsync(It.IsAny <int>())).ReturnsAsync(author);
_mockAuthorRepository.Setup(s => s.UpdateAsync(It.IsAny <Author>()));
var sut = CreateAuthorController(_mockAuthorRepository, _mapper, _mockLogger);
var result = await sut.UpdateAuthor(99, authorDto);
using (new AssertionScope())
{
result.GetObjectResult().Should().BeOfType <Author>();
result.GetObjectResult().FirstName.Should().Be(authorUpdated.FirstName);
result.GetObjectResult().LastName.Should().Be(authorUpdated.LastName);
result.GetObjectResult().Id.Should().Be(99);
}
}
public IActionResult UpdateAuthor(int authorId, [FromBody] AuthorUpdateDto updatedAuthor)
{
if (updatedAuthor == null)
{
return(BadRequest(ModelState));
}
if (authorId != updatedAuthor.Id)
{
return(BadRequest(ModelState));
}
if (!_unitOfWork.AuthorRepository.AuthorExists(authorId))
{
ModelState.AddModelError("", "Author doesn't exist!");
}
if (!ModelState.IsValid)
{
return(StatusCode(404, ModelState));
}
if (!_unitOfWork.AuthorRepository.UpdateAuthor(updatedAuthor))
{
ModelState.AddModelError("", $"Something went wrong updating the author " + $"{updatedAuthor.AuthorFirstName} {updatedAuthor.AuthorLastName}");
return(StatusCode(500, ModelState));
}
_unitOfWork.Commit();
return(NoContent());
}
public async Task <IActionResult> PutAuthor(int id, AuthorUpdateDto authorDto)
{
var author = await _context.Authors.FindAsync(id);
if (author == null)
{
return(NotFound());
}
_context.Entry(author).State = EntityState.Modified;
_mapper.Map(authorDto, author);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AuthorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public bool UpdateAuthor(AuthorUpdateDto authorToUpdateDto)
{
var authorToUpdate = MapConfig.Mapper.Map <Author>(authorToUpdateDto);
_authorContext.Update(authorToUpdate);
return(Save());
}
public async Task <AuthorOutputDto> Put([FromBody] AuthorUpdateDto input)
{
var book = _mapper.Map <Author>(input);
var result = await _authorManager.UpdateAsync(book);
return(_mapper.Map <AuthorOutputDto>(result));
}
public async Task <ActionResult> Update(int id, [FromBody] AuthorUpdateDto authorUpdateDto)
{
Author author = await _authorRepository.FindByIdAsync(id);
if (author == null)
{
return(NotFound());
}
_mapper.Map(authorUpdateDto, author);
await _authorRepository.UpdateAsync(author);
return(NoContent());
}
public ActionResult <Author> Update(AuthorUpdateDto AuthorUpdateDto)
{
try
{
return(service.Update(AuthorUpdateDto));
}
catch (ArgumentException error)
{
return(NotFound(error.Message));
}
catch (Exception error)
{
return(Conflict(error.Message));
}
}
public async Task UpdateAuthor(Guid id, AuthorUpdateDto authorUpdateDto)
{
ValidateId(id);
ValidateEntity(authorUpdateDto);
var author = await _authorRepository.GetByIdAsync(id);
if (author == null)
{
throw new AuthorNotFoundException(id);
}
_mapper.Map(authorUpdateDto, author);
await _authorRepository.SaveAsync();
}
public async Task <IActionResult> PutAuthor(int id, AuthorUpdateDto authorDto)
{
if (id < 1 || id != authorDto.Id || authorDto == null)
{
return(BadRequest("Invalid author details provided."));
}
if (!ModelState.IsValid)
{
return(BadRequest(new { Author = ModelState, Message = "Incomplete author details." }));
}
await _authorService.Update(_mapper.Map <Author>(authorDto));
return(NoContent());
}
public ActionResult Put(Guid id, AuthorUpdateDto authorDto)
{
var author = _bookLibrary.Authors.FirstOrDefault(p => p.Id == id);
if (author is null)
{
author = new Author {
FirstName = authorDto.FirstName, LastName = authorDto.LastName, Id = id
};
_bookLibrary.Authors.Add(author);
_bookLibrary.SaveChanges();
return(CreatedAtAction("Get", new { id = id }, author));
}
author.FirstName = authorDto.FirstName;
author.LastName = authorDto.LastName;
_bookLibrary.SaveChanges();
return(NoContent());
}
public Author Update(AuthorUpdateDto dto)
{
var isExist = GetDetail(dto.FullName);
if (isExist != null && dto.Id != isExist.Id)
{
throw new Exception(dto.FullName + " existed");
}
var entity = new Author
{
Id = dto.Id,
FullName = FormatString.Trim_MultiSpaces_Title(dto.FullName, true),
Biography = dto.Biography,
Image = dto.Image
};
return(repository.Update(entity));
}
public async Task <IActionResult> UpdateAuthor(int authorId, AuthorUpdateDto authorUpdateDto)
{
var author = await _unitOfWork.Author.GetById(authorId);
if (author != null)
{
var result = _mapper.Map(authorUpdateDto, author);
await _unitOfWork.Author.Update(author);
await _unitOfWork.Save();
_logger.LogInformation("PUT api/author/{authorId} => OK", authorId);
return(Ok());
}
else
{
_logger.LogInformation("PUT api/author/{authorId} => NOT OK", authorId);
return(NoContent());
}
}
public async Task <IActionResult> Update(int id, [FromBody] AuthorUpdateDto authorDto)
{
var location = GetControllerActionNames();
try
{
_logger.LogInfo($"{location}: Update attempted on record with id: {id}.");
if (id < 1 || authorDto == null || id != authorDto.Id)
{
_logger.LogWarn($"{location}: Update failed with bad data - id: {id}.");
return(BadRequest());
}
var isExists = await _authorRepository.isExists(id);
if (!isExists)
{
_logger.LogWarn($"{location}: Failed to retrieve record with id: {id}.");
return(NotFound());
}
if (!ModelState.IsValid)
{
_logger.LogWarn($"{location}: Data was incomplete.");
return(BadRequest(ModelState));
}
var author = _mapper.Map <Author>(authorDto);
var isSuccess = await _authorRepository.Update(author);
if (!isSuccess)
{
return(InternalError($"{location}: Update failed for record with id: {id}."));
}
_logger.LogInfo($"{location}: Record with id: {id} successfully updated.");
return(NoContent());
}
catch (Exception e)
{
return(InternalError($"{location}: {e.Message} - {e.InnerException}"));
}
}
public async Task <ActionResult> UpdatePartial(int id, [FromBody] JsonPatchDocument <AuthorUpdateDto> authorUpdateDtoPatchDoc)
{
Author authorFromDb = await _authorRepository.FindByIdAsync(id);
if (authorFromDb == null)
{
return(NotFound());
}
AuthorUpdateDto authorUpdateDto = _mapper.Map <AuthorUpdateDto>(authorFromDb);
authorUpdateDtoPatchDoc.ApplyTo(authorUpdateDto);
if (!TryValidateModel(authorUpdateDto))
{
return(ValidationProblem(ModelState));
}
_mapper.Map(authorUpdateDto, authorFromDb);
await _authorRepository.UpdateAsync(authorFromDb);
return(NoContent());
}
