public ConfirmationResponse Execute(EditPersonRequest request)
{
request.ThrowExceptionIfInvalid();
if (request.ForUserId != Identity.FromString(request.UserId))
{
throw new UseCaseException("Can't change data of another user.");
}
var entity = _personRepository.Read(request.ForUserId);
if (entity.Email != request.Email && _personRepository.CheckIfEmailExists(request.Email))
{
throw new UseCaseException("Person with same email already exists.");
}
entity.FirstName = request.FirstName;
entity.LastName = request.LastName;
entity.DisplayName = request.DisplayName;
entity.Email = request.Email;
_personRepository.Update(entity);
return(new ConfirmationResponse("User updated successfully.")
{
Id = entity.Id,
});
}
public async Task <PersonResponse> EditPersonAsync(EditPersonRequest request)
{
Person existingRecord = await _personRespository.GetAsync(request.Id);
if (existingRecord == null)
{
throw new ArgumentException($"Entity with {request.Id} is not present");
}
if (request.PictureId != null)
{
FAGBinary existingPicture = await _fagBinaryRespository.GetAsync(request.PictureId);
if (existingPicture == null)
{
throw new NotFoundException($"Picture with {request.PictureId} is not present");
}
}
Person entity = _personMapper.Map(request);
Person result = _personRespository.Update(entity);
int modifiedRecords = await _personRespository.UnitOfWork.SaveChangesAsync();
_logger.LogInformation(Logging.Events.Edit, Messages.NumberOfRecordAffected_modifiedRecords, modifiedRecords);
_logger.LogInformation(Logging.Events.Edit, Messages.ChangesApplied_id, result?.Id);
return(_personMapper.Map(result));
}
public async Task <IActionResult> EditPersonAsync(int personId, EditPersonRequest editPersonRequest)
{
await _personsRepo.EditAsync(personId, editPersonRequest.FirstName, editPersonRequest.LastName,
editPersonRequest.Gender, editPersonRequest.PrivateNumber, editPersonRequest.BirthDate,
editPersonRequest.CityId, editPersonRequest.PhoneNumbers?.ToPhoneNumbers().ToList());
return(Ok());
}
public async Task <Person> UpdatePersonAsync(String token, String ID, EditPersonRequest editPersonRequest)
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
PersonsControllerClient _personClient = new PersonsControllerClient(httpClient);
var a = await _personClient.UpdatePersonAsync(long.Parse(ID), editPersonRequest);
return(a);
}
public IActionResult UpdatePerson(long id, [FromBody] EditPersonRequest request)
{
var person = PersonService.UpdatePerson(id, request);
if (person == null)
{
return(NotFound());
}
return(Ok(person));
}
public Person Map(EditPersonRequest request)
{
if (request == null)
{
return(null);
}
Person person = new Person
{
Id = request.Id,
LastName = request.LastName,
FirstName = request.FirstName,
Sex = request.Sex,
Department = request.Department,
PhoneOffice = request.PhoneOffice,
PhonePrivate = request.PhonePrivate,
Email = request.Email,
PictureId = request.PictureId
};
return(person);
}
public async Task <IActionResult> Update(Guid id, [FromBody] EditPersonRequest request,
CancellationToken cancellationToken)
{
if (id == Guid.Empty)
{
return(BadRequest("Invalid Person Id"));
}
if (request.Name.Trim().Length == 0)
{
return(BadRequest("Person Name can not be empty"));
}
var existingPerson =
await _peopleCosmosStore.FindAsync(id.ToString(), cancellationToken : cancellationToken);
if (existingPerson == null)
{
return(NotFound());
}
var personToSave = new Person
{
Id = id.ToString(),
Name = request.Name
};
var result = await _peopleCosmosStore.UpdateAsync(personToSave, cancellationToken : cancellationToken);
var personId = result.Entity.Id;
if (personId == null)
{
return(BadRequest());
}
return(Ok(personId));
}
public Person UpdatePerson(long id, EditPersonRequest request)
{
var person = PersonsRepository.UpdatePerson(id, request.Name, request.Surname, request.ProfilePictureUrl, request.Birthday);
return(Mapper.Map <Person>(person));
}
public ActionResult <EditPersonResponse> EditPerson([FromBody] EditPersonRequest request)
{
return(_personService.EditPerson(request));
}
public EditPersonResponse EditPerson(EditPersonRequest request)
{
try
{
var person = _db.Persons.Where(t => t.Id == request.PersonId).Include(t => t.PersonPhones).FirstOrDefault();
person.Fname = request.Fname;
person.Lname = request.Lname;
person.PersonalNumber = request.PersonalNumber;
person.BirthDate = request.BirthDate;
person.GenderId = request.GenderId;
person.CityId = request.CityId;
if (request.PersonPhones == null || request.PersonPhones.Count == 0)
{
if (person.PersonPhones != null)
{
person.PersonPhones = null;
//_db.PersonPhones.RemoveRange(person.PersonPhones.ToList());
}
}
else
{
var personPhones = person.PersonPhones.ToList();
if (personPhones == null)
{
var newPhones = request.PersonPhones.Select(t => new PersonPhone
{
PhoneNumber = t.PhoneNumber,
PhoneTypeId = (int)Enum.Parse(typeof(PhoneType), t.PhoneType)
}).ToList();
_db.PersonPhones.AddRange(newPhones);
}
else
{
var phoneIds = request.PersonPhones.Where(t => t.Id != null).Select(t => t.Id).ToList();
var removedPhones = personPhones.Where(t => !phoneIds.Contains(t.Id)).ToList();
var personPhoneIds = personPhones.Select(t => t.Id).ToList();
var editedPhones = (from t in request.PersonPhones
where t.Id != null &&
personPhoneIds.Contains(t.Id.Value)
select new PersonPhone
{
Id = t.Id.Value,
PhoneNumber = t.PhoneNumber
}).ToList();
var newPhones = (from t in request.PersonPhones
where t.Id == null
select new PersonPhone
{
PhoneNumber = t.PhoneNumber,
PhoneTypeId = (int)Enum.Parse(typeof(PhoneType), t.PhoneType)
}).ToList();
_db.PersonPhones.RemoveRange(removedPhones);
_db.PersonPhones.UpdateRange(editedPhones);
_db.PersonPhones.AddRange(newPhones);
_db.SaveChanges();
}
}
return(Success(new EditPersonResponse()
{
PersonId = person.Id
}));
}
catch (Exception ex)
{
return(Error(new EditPersonResponse(), RsStrings.EditPersonUnexpectedException));
}
}
