public void Should_Update_Person()
{
var existingPersonId = 1;
var updatePerson = new UpdatePersonDto
{
PersonId = existingPersonId,
FirstName = "NewName",
LastName = "NewName",
Gender = Gender.Female,
BirthDate = new DateTime(2000, 1, 1)
};
_personAppService.Update(updatePerson);
UsingDbContext(context =>
{
var existingPerson = context.People.Single(p => p.Id == existingPersonId);
existingPerson.FirstName.ShouldBe(updatePerson.FirstName);
existingPerson.LastName.ShouldBe(updatePerson.LastName);
existingPerson.BirthDate.ShouldBe(updatePerson.BirthDate);
existingPerson.Gender.ShouldBe(updatePerson.Gender);
existingPerson.IsDeleted.ShouldBe(updatePerson.IsDeleted);
});
}
private void AddUpdateOrDelete(UpdatePersonDto dto, Person person)
{
person.Phones
.Where(phone =>
!dto.Phones
.Any(phoneDto => phoneDto.Id == phone.Id)
)
.ToList()
.ForEach(deleted =>
person.Phones.Remove(deleted)
);
foreach (var phoneDto in dto.Phones)
{
if (phoneDto.Id == default(Guid))
{
person.Phones
.Add(Mapper.Map <PersonPhone>(phoneDto));
}
else
{
Mapper.Map(phoneDto,
person.Phones.
SingleOrDefault(c => c.Id == phoneDto.Id));
}
}
}
public Person Update(int personId, UpdatePersonDto updatePersonDto)
{
using (IDbConnection connection = new SqlConnection(SystemVariables.ConnectionString))
{
Person person = GetById(personId);
if (person == null)
{
return(null);
}
connection.Open();
using (var transaction = connection.BeginTransaction())
{
try
{
connection.Execute(Queries.PersonQueries.UpdatePersonDetails, new { updatePersonDto.IsEnabled, updatePersonDto.IsAuthorised, updatePersonDto.IsValid, personId }, transaction);
connection.Execute(Queries.PersonQueries.DeletePersonColours, new { personId }, transaction);
connection.Execute(Queries.PersonQueries.InsertPersonColours(updatePersonDto.FavouriteColours, personId), null, transaction);
transaction.Commit();
connection.Close();
}
catch (SqlException ex)
{
Debug.WriteLine(ex.Message);
transaction.Rollback();
return(null);
}
}
var updatedPerson = GetById(personId);
return(updatedPerson);
}
}
public override async Task <PersonDto> Update(UpdatePersonDto input)
{
CheckUpdatePermission();
using (var uow = UnitOfWorkManager.Begin()) {
var person = await _personRepository
.GetAllIncluding(
c => c.Phones
)
.FirstOrDefaultAsync(c => c.Id == input.Id);
ObjectMapper.Map(input, person);
foreach (var phone in person.Phones.ToList())
{
if (input.Phones.All(x => x.Id != phone.Id))
{
await _personPhonesRepository.DeleteAsync(phone.Id);
}
}
// or use extension
// _personPhonesRepository
// .RemoveNonexistentEntities(
// person.Phones,
// input.Phones);
uow.Complete();
}
return(await Get(input));
}
public async Task <IActionResult> UpdatePersonAsync([FromBody] UpdatePersonDto updatePersonDto, CancellationToken cancellationToken)
{
_personService.UpdatePerson(updatePersonDto);
await _unitOfWork.CompleteWithAuditAsync(cancellationToken);
return(NoContent());
}
public ActionResult <UpdatePersonResult> UpdatePerson(int accountId, UpdatePerson updatePerson)
{
var updatePersonDto = new UpdatePersonDto()
{
DOME_header = new R542a.domeHeaderDto()
{
langue = "fr",
deviceTypeSpecified = true,
deviceType = (int)DeviceType,
dateSpecified = true,
date = AuthentificationHelper.date,
version = AuthentificationHelper.version,
},
accountId = accountId,
accountIdSpecified = true,
DOME_createPerson = new R542a.CreatePersonInnerDto()
{
personCivilityId = (int?)updatePerson.PersonCivility ?? -1,
personCivilityIdSpecified = updatePerson.PersonCivility.HasValue,
personBirthDate = (DateTime?)updatePerson.PersonBirthDate ?? DateTime.MinValue.Date,
personBirthDateSpecified = updatePerson.PersonBirthDate.HasValue,
personAddressComp1 = updatePerson.PersonAddressComp1,
personAddressComp2 = updatePerson.PersonAddressComp2,
personBirthName = updatePerson.PersonBirthName,
personCedex = updatePerson.PersonCedex,
personCityName = updatePerson.PersonCityName,
personCityZipCode = updatePerson.PersonCityZipCode,
personComment = updatePerson.PersonComment,
personEmail1 = updatePerson.PersonEmail1,
personEmail2 = updatePerson.PersonEmail2,
personFirstName = updatePerson.PersonFirstName,
personINSA = updatePerson.PersonInsa,
personINSC = updatePerson.PersonInsc,
personJob = updatePerson.PersonJob,
personLastName = updatePerson.PersonLastName,
personLieuDit = updatePerson.PersonLieuDit,
personMobilePhoneNumber = updatePerson.PersonMobilePhoneNumber,
personNIR = updatePerson.PersonNir,
personPhoneNumber = updatePerson.PersonPhoneNumber,
personPostBox = updatePerson.PersonPostBox,
personRoadName = updatePerson.PersonRoadName,
personRoadNumber = updatePerson.PersonRoadNumber,
personRoadType = updatePerson.PersonRoadType,
personRPPS = updatePerson.PersonRpps,
specialCriteria = updatePerson.SpecialCriteria,
}
};
var data = DomeCallSoap.UpdatePerson(updatePersonDto);
if (data.statusId == 0)
{
return(new ActionResult <UpdatePersonResult>(true, new UpdatePersonResult(data)));
}
return(new ActionResult <UpdatePersonResult>(false, new UpdatePersonResult(data), new Message(MessageType.Error, data.statusErrorMessage)));
}
public IActionResult Put(int id, [FromBody] UpdatePersonDto updatePersonDto)
{
var person = PersonRepository.Update(id, updatePersonDto);
if (person == null)
{
return(NotFound());
}
return(Ok(person));
}
public ActionResult Update([FromBody] UpdatePersonDto dto, [FromRoute] int id)
{
var isUpdated = _personService.Update(id, dto);
if (isUpdated)
{
return(NotFound());
}
return(Ok());
}
public async Task <IActionResult> Get([FromBody] UpdatePersonDto dto)
{
Person person = await _context.Insert(new Person("TESSTETESD"));
IAsyncCursor <Person> cursor = await _context.Collection.FindAsync(Builders <Person> .Filter.Eq(a => a.Id, person.Id));
Person result = await cursor.FirstOrDefaultAsync();
return(Ok(result));
}
public async Task <string> UpdatePersonAsync(string id, UpdatePersonDto person)
{
var personJson = JsonConvert.SerializeObject(person);
var buffer = System.Text.Encoding.UTF8.GetBytes(personJson);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = await _httpClient.PutAsync($"person/{id}", byteContent);
var res = CustomDeserializeObjectResponseAsync <string>(response);
return(await Task.Run(() => string.Empty));
}
public async Task <ActionResult> UpdatePerson([FromRoute] string id, [FromBody] UpdatePersonDto person)
{
var lastPerson = _service.GetPersonById(id);
if (lastPerson == null)
{
return(NotFound());
}
lastPerson.UpdatePerson(person.Name, person.LastName, person.PhoneNumber);
await _service.UpdatePerson(id, lastPerson);
return(Created(string.Empty, lastPerson.Id));
}
public void Should_Not_Update_Person_If_Person_Id_Is_Out_Of_Range()
{
var newPerson = new UpdatePersonDto
{
//PersonId = 0 by default
FirstName = "Lo",
LastName = "Celso",
Gender = Gender.Male,
BirthDate = new DateTime(1996, 4, 9),
OtherDetails = "This person does not exist in database seed"
};
newPerson.PersonId.ShouldNotBeInRange(1, int.MaxValue);
Should.Throw <AbpValidationException>(() => _personAppService.Update(newPerson), "PersonId = 0 should be out of range");
}
public override async Task <PersonDto> Update(UpdatePersonDto input)
{
CheckUpdatePermission();
using (var uow = UnitOfWorkManager.Begin()) {
var person = await _personRepository
.GetAllIncluding(
c => c.Phones
)
.FirstOrDefaultAsync(c => c.Id == input.Id);
ObjectMapper.Map(input, person);
uow.Complete();
}
return(await Get(input));
}
public void Should_Not_Update_Person_If_FirstName_Is_Null()
{
var existingPerson = GetPersonById(1);
var personWithNullFirstName = new UpdatePersonDto
{
PersonId = existingPerson.Id,
LastName = existingPerson.LastName,
Gender = existingPerson.Gender,
BirthDate = existingPerson.BirthDate,
BirthPlace = existingPerson.BirthPlace,
OtherDetails = existingPerson.OtherDetails
};
personWithNullFirstName.FirstName.ShouldBeNull();
Should.Throw <AbpValidationException>(() => _personAppService.Update(personWithNullFirstName));
}
public bool Update(int id, UpdatePersonDto dto)
{
var people = _dbContext
.People
.FirstOrDefault(e => e.Id == id);
if (people is null)
{
return(false);
}
people.Name = dto.Name;
people.Surname = dto.Surname;
people.Email = dto.Email;
people.BirthDate = dto.BirthDate;
_dbContext.SaveChanges();
return(true);
}
private void AddOrUpdatePhones(UpdatePersonDto dto, Person person)
{
foreach (var phoneDto in dto.Phones)
{
if (phoneDto.Id == default(Guid))
{
person.Phones
.Add(Mapper.Map <PersonPhone>(phoneDto));
}
else
{
Mapper.Map(phoneDto,
person.Phones.
SingleOrDefault(c => c.Id == phoneDto.Id));
}
}
}
public void Should_Not_Update_Person_If_Details_Length_Is_Oversize()
{
var existingPerson = GetPersonById(1);
var oversizedDetails = Strings.GenerateRandomString(Person.MaxDetailsLength + 1);
var personWithOversizedDetailsLength = new UpdatePersonDto
{
PersonId = existingPerson.Id,
FirstName = existingPerson.FirstName,
LastName = existingPerson.LastName,
Gender = existingPerson.Gender,
BirthDate = existingPerson.BirthDate,
BirthPlace = existingPerson.BirthPlace,
OtherDetails = oversizedDetails
};
Should.Throw <AbpValidationException>(() => _personAppService.Update(personWithOversizedDetailsLength));
}
public void Should_Not_Update_Person_If_Gender_Value_Is_Invalid()
{
var existingPerson = GetPersonById(1);
var personWithInvalidGenderValue = new UpdatePersonDto
{
PersonId = existingPerson.Id,
FirstName = existingPerson.FirstName,
LastName = existingPerson.LastName,
BirthDate = existingPerson.BirthDate,
BirthPlace = existingPerson.BirthPlace,
OtherDetails = existingPerson.OtherDetails
};
Should.Throw <AbpValidationException>(() => _personAppService.Update(personWithInvalidGenderValue));
personWithInvalidGenderValue.Gender = (Gender)3; //Value can only be Female = 1 or Male = 2.
Should.Throw <AbpValidationException>(() => _personAppService.Update(personWithInvalidGenderValue));
}
public void Should_Not_Update_Or_Add_Person_If_Person_Id_Does_Not_Exist()
{
var initialPeopleCount = GetPeopleCount();
var notExistingPersonId = GenerateNotExistingPersonId();
//All input fields are valid but this person do not exist.
var notExistingPerson = new UpdatePersonDto
{
PersonId = notExistingPersonId,
FirstName = "Lo",
LastName = "Celso",
Gender = Gender.Male,
BirthDate = new DateTime(1996, 4, 9),
OtherDetails = "This person does not exist in database seed"
};
Should.Throw <EntityNotFoundException>(() => _personAppService.Update(notExistingPerson));
GetPeopleCount().ShouldBe(initialPeopleCount);
}
public async ValueTask <ActionResult> PutPerson(int id, UpdatePersonDto updatePersonDto)
{
if (_fileStorageService.IsBase64(updatePersonDto.Picture))
{
var personPicture = Convert.FromBase64String(updatePersonDto.Picture);
updatePersonDto.Picture = await _fileStorageService.SaveFile(personPicture, "jpg", "people");
}
Person person = _repo.GetPersonById(id);
if (person == null)
{
return(NotFound());
}
_mapper.Map(updatePersonDto, person);
_repo.UpdatePerson(person);
_repo.SaveChanges();
return(NoContent());
}
public ActionResult PatchMovie(JsonPatchDocument <UpdatePersonDto> jsonDoc, int id)
{
Person person = _repo.GetPersonById(id);
if (person == null)
{
return(NotFound());
}
UpdatePersonDto personToPatch = _mapper.Map <UpdatePersonDto>(person);
jsonDoc.ApplyTo(personToPatch);
if (!TryValidateModel(personToPatch))
{
return(ValidationProblem(ModelState));
}
_mapper.Map(personToPatch, person);
_repo.UpdatePerson(person);
_repo.SaveChanges();
return(NoContent());
}
public void Update(UpdatePersonDto input)
{
Person person = _personRepository.Get(input.PersonId);
MapToEntity(input, person);
}
public void UpdatePerson(UpdatePersonDto updatePersonDto)
{
var updatedPerson = _mapper.Map <Person>(updatePersonDto);
_repositoryContainer.PersonRepository.Update(updatedPerson);
}
public UpdatePersonResponseDto UpdatePerson(UpdatePersonDto updatePersonDto)
{
return(DomeClientSoapCallHelper.Call <DOME_BUS_EAI_R542aUpdatePersonWSClient, DOME_BUS_EAI_R542aUpdatePersonWS, UpdatePersonResponseDto>
((client) => { return client.updatePerson(updatePersonDto); }));
}
protected void MapToEntity(UpdatePersonDto input, Person person)
{
_objectMapper.Map(input, person);
}