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); }