public async Task <IActionResult> UpdatePerson(int id, PersonForUpdateDto person)
{
var personFromRepo = await _personRepository.GetPersonAsync(id);
if (personFromRepo == null)
{
return(NotFound());
}
var validationResults = new PersonForUpdateDtoValidator().Validate(person);
validationResults.AddToModelState(ModelState, null);
if (!ModelState.IsValid)
{
return(BadRequest(new ValidationProblemDetails(ModelState)));
//return ValidationProblem();
}
_mapper.Map(person, personFromRepo);
_personRepository.UpdatePerson(personFromRepo);
await _personRepository.SaveAsync();
return(NoContent());
}
public IActionResult UpdatePointOfIntrest(int id, [FromBody] PersonForUpdateDto updatedPerson)
{
if (updatedPerson == null)
{
return(BadRequest());
}
if (updatedPerson.FirstName.Equals(updatedPerson.LastName))
{
ModelState.AddModelError("LastName", "First Name and Last Name should be different.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var foundPerson = PeopleStore.CurrentStore.People.FirstOrDefault(p => p.Id == id);
if (foundPerson == null)
{
NotFound();
}
foundPerson.FirstName = updatedPerson.FirstName;
foundPerson.LastName = updatedPerson.LastName;
foundPerson.Age = updatedPerson.Age;
foundPerson.Address = updatedPerson.Address;
return(NoContent()); //204 => can also return 200OK and pass updated resource;
}
public async Task <IActionResult> UpdatePerson(Guid id, [FromBody] PersonForUpdateDto person)
{
var personEntity = HttpContext.Items["person"] as Person;
_mapper.Map(person, personEntity);
await _repository.SaveAsync();
return(NoContent());
}
public async Task <IActionResult> UpdatePerson(int id, PersonForUpdateDto personForUpdate)
{
var personFromRepo = await _repository.GetPerson(id);
try {
_mapper.Map(personForUpdate, personFromRepo);
await _repository.SaveAll();
return(NoContent());
} catch (Exception) {
return(NoContent());
}
}
public async Task <IActionResult> Edit(int id, PersonForUpdateDto personForUpdateDto)
{
if (!ModelState.IsValid)
{
return(BadRequest("Некоректные данные"));
}
var person = _mapper.Map <Person>(personForUpdateDto);
var phone = await _context.Phones.SingleOrDefaultAsync(p => p.Id == personForUpdateDto.PhoneId);
if (phone == null)
{
phone = new Phone
{
PhoneNumber = personForUpdateDto.PhoneNumber
};
await _context.Phones.AddAsync(phone);
person.PhoneId = phone.Id;
}
if (id != person.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(person);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PersonExists(person.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(IndexEdit)));
}
return(View(person));
}
public IActionResult UpdatePerson(Guid id, [FromBody] PersonForUpdateDto person)
{
try
{
if (id == null || person == null)
{
_logger.LogError("Person object sent from client is null.");
return(BadRequest("Person object is null"));
}
if (!ModelState.IsValid)
{
_logger.LogError("Invalid person object sent from client.");
return(BadRequest("Invalid model object"));
}
if (IsPersonAdded(person.Id, person.FullName))
{
_logger.LogError($"person with full name: {person.FullName} added before.");
return(BadRequest("Person added before"));
}
var personEntity = _repository.Person.GetPersonById(id);
if (personEntity == null)
{
_logger.LogError($"Person with id: {id}, hasn't been found in db.");
return(NotFound());
}
_mapper.Map(person, personEntity);
_repository.Person.UpdatePerson(personEntity);
_repository.Save();
return(NoContent());
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside UpdatePerson action: {ex.Message}");
if (ex.InnerException != null)
{
_logger.LogError($"Inner Exception: {ex.InnerException.Message}");
}
return(StatusCode(500, "Internal server error"));
}
}
public async Task <IActionResult> Put([FromRoute] int id, [FromBody] PersonForUpdateDto person)
{
if (person == null)
{
return(BadRequest());
}
if (!await _repository.EntityExistsAsync <Person>(id))
{
return(NotFound());
}
var personFromRepo = await _repository.GetByIdAsync <Person>(id);
if (personFromRepo == null)
{
return(NotFound());
}
try
{
Mapper.Map(person, personFromRepo);
await _repository.UpdateAsync(personFromRepo);
}
catch (DbUpdateConcurrencyException)
{
if (!await _repository.EntityExistsAsync <Person>(id))
{
return(NotFound());
}
throw;
}
return(NoContent());
}
