public Person UpdatePerson(Guid personId, PersonUpdateRequest personUpdateRequest) { DateTime updatedAt = DateTime.UtcNow; return(_person.FindOneAndUpdateAsync(p => p.PersonId == personId, Person.UpdateBuilder(personUpdateRequest, updatedAt)).Result); }
public PersonResponse Update(PersonUpdateRequest item) { var controller = new PersonController(classmates); return(ValidateAndExecute(() => controller.ValidateUpdate(item), () => controller.ExecuteUpdate(item))); }
public static Person MapEntityFromRequest(PersonUpdateRequest request, Person entity) { entity.FirstName = request.FirstName; entity.LastName = request.LastName; entity.Phone = request.Phone; return(entity); }
public static UpdateDefinition <Person> UpdateBuilder(PersonUpdateRequest personUpdateRequest, DateTime updatedAt) { return(Builders <Person> .Update .Set(p => p.Fullname, personUpdateRequest.Fullname) .Set(p => p.EmailId, personUpdateRequest.EmailId) .Set(p => p.Age, personUpdateRequest.Age) .Set(p => p.UpdatedAt, updatedAt)); }
public IActionResult UpdatePerson([FromRoute] string personId, [FromBody] PersonUpdateRequest personUpdateRequest) { Person person = _mapper.Map <Person>(personUpdateRequest); person.PersonId = personId; _entityRepository.Update(person); _unitOfWork.Commit(); return(Ok()); }
public void UpdatePerson_OK_すべての値を正常値で更新() { var requestObject = new PersonCreateRequest { PersonCode = new String('U', 20), Name = new String('U', 256), LoginId = new String('U', 256), Title = new String('U', 100), Description = new String('U', 1024), Status = PersonStatus.NORMAL.ToString(), SortNo = int.MaxValue, Tags = new List <string> { new String('U', 100) }, }; var request = new HttpRequestMessage(HttpMethod.Post, "/api/v1/persons"); request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write"); request.Content = new StringContent(JsonUtil.Serialize(requestObject), Encoding.UTF8, "application/json"); var response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult(); var responseBody = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult(); var person = JsonUtil.Deserialize <Person>(responseBody); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); var updateRequestObject = new PersonUpdateRequest { PersonCode = new String('V', 20), Name = new String('V', 256), LoginId = new String('V', 256), Title = new String('V', 100), Description = new String('V', 1024), Status = PersonStatus.SUSPENDED.ToString(), SortNo = 0, Tags = new List <string> { new String('V', 100) }, }; request = new HttpRequestMessage(HttpMethod.Patch, $"/api/v1/persons/{person.PersonId}"); request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write"); request.Content = new StringContent(JsonUtil.Serialize(updateRequestObject), Encoding.UTF8, "application/json"); response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult(); responseBody = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult(); person = JsonUtil.Deserialize <Person>(responseBody); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); Assert.AreEqual(person.PersonCode, new String('V', 20)); Assert.AreEqual(person.Name, new String('V', 256)); Assert.AreEqual(person.LoginId, new String('V', 256)); Assert.AreEqual(person.Title, new String('V', 100)); Assert.AreEqual(person.Description, new String('V', 1024)); Assert.AreEqual(person.Status, PersonStatus.SUSPENDED.ToString()); Assert.AreEqual(person.SortNo, 0); Assert.AreEqual(person.Tags[0], new String('V', 100)); }
public static UpdateDefinition <Person> UpdateBuilder(PersonUpdateRequest personUpdateRequest, DateTime updatedAt) { return(Builders <Person> .Update .Set(p => p.FirstName, personUpdateRequest.FirstName) .Set(p => p.GraduationDate, personUpdateRequest.GraduationDate) .Set(p => p.EmailId, personUpdateRequest.EmailId) .Set(p => p.gender, personUpdateRequest.gender) .Set(p => p.UpdatedAt, updatedAt)); }
public Person UpdatePerson(Guid id, PersonUpdateRequest personUpdateRequest) { try { DateTime updatedAt = DateTime.UtcNow; var person = _person.FindOneAndUpdateAsync(p => p.personId == id, Person.UpdateBuilder(personUpdateRequest, updatedAt)).Result; return(person); } catch { throw; } }
public static PersonUpdateRequest MapUpdateRequestFromViewModel(PersonViewModel model) { var request = new PersonUpdateRequest(); request.UId = model.UId; request.FirstName = model.FirstName; request.LastName = model.LastName; request.Phone = model.Phone; return(request); }
internal static PersonUpdateRequest GetPersonUpdateRequest(PersonSelectRequest selectRequest, PersonInsertRequest insertRequest) { var request = new PersonUpdateRequest(); request.UId = selectRequest.UId; request.FirstName = insertRequest.FirstName; request.LastName = insertRequest.LastName; request.Phone = insertRequest.Phone; return(request); }
public HttpResponseMessage Put(PersonUpdateRequest model) { if (!ModelState.IsValid) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } SuccessResponse response = new SuccessResponse(); _svc.Put(model); return(Request.CreateResponse(HttpStatusCode.OK, response)); }
public ActionResult <Person> Put(Guid id, [FromBody] PersonUpdateRequest personUpdateRequest) { var sw = Stopwatch.StartNew(); var person = personServices.UpdatePerson(id, personUpdateRequest); sw.Stop(); LoginDuration .WithLabels("Edit_Person") .Observe(sw.Elapsed.TotalSeconds); return(person); }
public void Update(PersonUpdateRequest model) { DataProvider.ExecuteNonQuery(GetConnection, "dbo.Person_Update", inputParamMapper : delegate(SqlParameterCollection paramCollection) { paramCollection.AddWithValue("@Id", model.Id); MapCommonParameters(model, paramCollection); } ); return; }
public HttpResponseMessage Update(PersonUpdateRequest model) { if (!ModelState.IsValid) { return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState)); } _personService.Update(model); SuccessResponse response = new SuccessResponse(); return(Request.CreateResponse(HttpStatusCode.OK, response)); }
public async Task <Response <object> > Handle(PersonUpdateRequest request, CancellationToken cancellationToken) { if (await _personRepository.Exists(p => p.Id.Equals(request.Id))) { return(new(HttpStatusCode.NotFound)); } var person = request.ToPerson(); _ = _personRepository.Update(person); _ = cache.SetAsync(CacheKeys.Person(request.Id), JsonSerializer.SerializeToUtf8Bytes(person), DateTime.Now.UntilMidnight(), cancellationToken); return(new(HttpStatusCode.NoContent)); }
//PUT / Update public void Update(PersonUpdateRequest model) { DataProvider.ExecuteNonQuery("dbo.People_Update" , inputParamMapper : delegate(SqlParameterCollection paramCollection) { paramCollection.AddWithValue("@UserId", model.UserId); paramCollection.AddWithValue("@FirstName", model.FirstName); paramCollection.AddWithValue("@MiddleName", model.MiddleName); paramCollection.AddWithValue("@LastName", model.LastName); paramCollection.AddWithValue("@ModifiedBy", model.ModifiedBy); } ); }
public async Task <PersonResponse> UpdatePartial(PersonUpdateRequest personToPatch, Person personFromDatabase) { if (await _personRepository.IsPersonExists(personToPatch.FirstName, personToPatch.LastName)) { throw new PersonAlreadyExists("Person already exists!"); } _mapper.Map(personToPatch, personFromDatabase); await _personRepository.Update(personFromDatabase); return(_mapper.Map <PersonResponse>(personFromDatabase)); }
public Person MapUpdateRequestToEntity(PersonUpdateRequest request) { var person = new Person { Id = request.Id, FirstName = request.FirstName, LastName = request.LastName, Email = request.Email, PhoneNumber = request.PhoneNumber, CompanyId = request.CompanyId }; return(person); }
public async Task Update(PersonUpdateRequest request) { // if (!request.IsValid()) return request.ValidationResult; // Como a pessoa é a raiz da agregação , deixei de expor os phones de forma direta var person = new Person(request.BusinessEntityID, request.Name); foreach (var phone in request.Phones) { person.UpdatePhone(phone.BusinessEntityID, phone.PhoneNumber, phone.PhoneNumberTypeID); } await _personService.Update(person); }
public HttpResponseMessage Update(PersonUpdateRequest model) { if (!ModelState.IsValid && model != null) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } try { _personService.Update(model); return(Request.CreateResponse(HttpStatusCode.OK, new SuccessResponse())); } catch (Exception ex) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex)); } }
public void UpdatePerson_NotFound_PersonIDの指定が存在しない() { var personId = "00000000-0000-0000-0000-000000000000"; var requestObject = new PersonUpdateRequest { PersonCode = new String('Z', 20), }; var request = new HttpRequestMessage(HttpMethod.Patch, $"/api/v1/persons/{personId}"); request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write"); request.Content = new StringContent(JsonUtil.Serialize(requestObject), Encoding.UTF8, "application/json"); var response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult(); Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode); }
public PersonUpdateResponse Update(PersonUpdateRequest request) { var response = new PersonUpdateResponse(); if (request.IsNotValid()) { response.Message = ConstHelper.REQUEST_NOT_VALID; return(response); } try { var entity = _personRepository.SelectOne(request.UId); if (entity == null) { response.Message = "There is no entity with this uid!"; return(response); } PersonMapper.MapEntityFromRequest(request, entity); var result = _personRepository.Update(entity); if (result.ModifiedCount != 1) { response.Message = "Update could not be done!"; return(response); } var model = PersonMapper.MapModelFromEntity(entity); response.Model = model; var cacheKey = "Person-" + request.UId; CacheManager.AddOrUpdateItem(cacheKey, model); } catch (Exception ex) { response.Message = string.Format("Update entity failed on database process!{0}{1}", Environment.NewLine, ex.Message); return(response); } response.Status = true; response.Message = "Person updated."; return(response); }
public void Put(PersonUpdateRequest model) { using (var con = new SqlConnection(ConfigurationManager.ConnectionStrings["ViaConnection"].ConnectionString)) { con.Open(); //Open Connection Here SqlCommand cmd = con.CreateCommand(); cmd.CommandText = "dbo.Person_Update"; //Sets the name of the stored procedure cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.AddWithValue("@Id", model.Id); //HERE WE ADD ID FROM UPDATE REQUEST cmd.Parameters.AddWithValue("@FullName", model.FullName); cmd.Parameters.AddWithValue("@Address", model.Address); cmd.Parameters.AddWithValue("@Phone", model.Phone); // 5. Call ExecuteNonQuery to send command cmd.ExecuteNonQuery(); } }
public void UpdatePerson_ValidationError_重複する値で更新() { var requestObject = new PersonCreateRequest { PersonCode = new String('W', 20), Name = new String('W', 256), LoginId = new String('W', 256), Title = new String('W', 100), Description = new String('W', 1024), Status = PersonStatus.NORMAL.ToString(), SortNo = int.MaxValue, Tags = new List <string> { new String('W', 100) }, }; var request = new HttpRequestMessage(HttpMethod.Post, "/api/v1/persons"); request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write"); request.Content = new StringContent(JsonUtil.Serialize(requestObject), Encoding.UTF8, "application/json"); var response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult(); var responseBody = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult(); var person = JsonUtil.Deserialize <Person>(responseBody); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); var updateRequestObject = new PersonUpdateRequest { PersonCode = "00001", }; request = new HttpRequestMessage(HttpMethod.Patch, $"/api/v1/persons/{person.PersonId}"); request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write"); request.Content = new StringContent(JsonUtil.Serialize(updateRequestObject), Encoding.UTF8, "application/json"); response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult(); responseBody = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult(); var error = JsonUtil.Deserialize <Error>(responseBody); Assert.AreEqual(ErrorCodes.ValidationError, error.Code); Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("PersonCode", StringComparison.OrdinalIgnoreCase))); Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode); }
public async Task <PersonResponse> Update(int id, PersonUpdateRequest request) { var personToUpdate = await _personRepository.GetById(id); if (personToUpdate == null) { throw new PersonNotFound("Person not found!"); } if (await _personRepository.IsPersonExists(request.FirstName, request.LastName)) { throw new PersonAlreadyExists("This person already exists!"); } _mapper.Map(request, personToUpdate); var person = await _personRepository.Update(personToUpdate); return(_mapper.Map <PersonResponse>(person)); }
public ActionResult <Person> UpdatePerson( [FromRoute] [Required(ErrorMessage = "DataAnnotationRequired")] [Guid(ErrorMessage = "DataAnnotationGuid")] string personId, [FromBody] PersonUpdateRequest request) { var personGuid = Guid.Parse(personId); var person = _personService.GetPerson(personGuid); if (person == null) { return(ErrorObjectResultFactory.NotFound()); } if (request.PersonCode != null && request.PersonCode != person.PersonCode && _personQueryService.ExistsPersonCode(request.PersonCode)) { return(ErrorObjectResultFactory.ValidationErrorDetail( string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayPersonPersonCode), "personCode")); } if (request.LoginId != null && request.LoginId != person.LoginId && _personQueryService.ExistsLoginId(request.LoginId)) { return(ErrorObjectResultFactory.ValidationErrorDetail( string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayPersonLoginId), "loginId")); } var dto = _mapper.Map <PersonUpdateRequest, PersonUpdateDto>(request); dto.PersonId = personGuid; var entity = _personService.UpdatePerson(dto); return(_mapper.Map <Domain.Entities.Person, Person>(entity)); }
public void Test01() { PersonApp app = new PersonApp(_session); PersonCreationRequest personCreationRequest = new PersonCreationRequest { Name = "xxx", ZipCode = "xxx", EMail = "xxx", Content = "xxx" }; app.Execute(personCreationRequest); personCreationRequest.ZipCode = "xxxxxx"; app.Execute(personCreationRequest); PersonUpdateRequest personUpdateRequest = new PersonUpdateRequest { Name = "xxx", City = "xxxx", Content = "xxxx" }; app.Execute(personUpdateRequest); PersonViewRequest personViewRequest = new PersonViewRequest(); var list = app.Execute(personViewRequest); var result = list.FirstOrDefault(); PersonDeletionRequest personDeletionRequest = new PersonDeletionRequest { PersonId = "1" }; app.Execute(personDeletionRequest); }
public async Task <IActionResult> Update(int id, [FromBody] PersonUpdateRequest request) { try { var person = await _personService.Update(id, request); return(Ok(person)); } catch (PersonNotFound exception) { return(NotFound(new { exception.Message })); } catch (PersonAlreadyExists exception) { return(BadRequest(new { exception.Message })); } }
public ActionResult <PersonModel> Update(PersonUpdateRequest request) { return(Ok(PersonService.Update(request))); }
public PersonModel Update(PersonUpdateRequest request) { var entity = PersonMapper.MapUpdateRequestToEntity(request); return(PersonMapper.MapEntityToModel(PersonRepository.Update(entity))); }
public async Task <bool> Execute(PersonUpdateRequest person) { var entity = mapper.Map <Person>(person); return(await personRepository.Update(entity)); }