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