public async Task <ActionResult> Put(Guid id, [FromBody] UpdatePersonModel model) { var request = new UpdatePersonRequest(id, model.NameConst, model.PrimaryName, model.BirthYear, model.DeathYear); var response = await _mediator.Send(request); return(Ok(response)); }
public async Task <Unit> UpdatePerson([FromRoute] int id, [FromQuery] UpdatePersonModel request) { var command = _mapper.Map <UpdatePersonCommand>(request); command.Id = id; return(await _mediator.Send(command)); }
public ActionResult UpdateDetails() { var identity = User.Identity.Name; if (identity == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } var registered_Person = (from a in db.Registered_Person where a.Person_ID == identity select a).FirstOrDefault(); if (registered_Person == null) { return(HttpNotFound()); } UpdatePersonModel b = new UpdatePersonModel(); b.Person_Name = registered_Person.Person_Name; b.Person_Surname = registered_Person.Person_Surname; b.Person_Email = registered_Person.Person_Email; return(View(b)); }
public async Task <object> Put(string id, [FromBody] UpdatePersonModel model) { var obj = hostelContext.ServicePersons.FirstOrDefault(d => d.GUID == id); if (obj != null) { obj.Address = model.Address; obj.Phone = model.Phone; obj.RealName = model.RealName; obj.Sex = model.Sex; obj.IdentityCard = model.IdentityCard; try { await hostelContext.SaveChangesAsync(); return(new { state = true, message = "更新用户数据成功!" }); } catch (Exception) { return(new { state = false, message = "数据保存失败,请确认数据是否完整!" }); } } else { return(new { state = false, message = "无效的用户GUID" }); } }
public async Task <IActionResult> PutAsync(string key, [FromBody] UpdatePersonModel model, [FromServices] IUpdatePersonModelToPersonMapper mapper) { var entity = mapper.Map(model); await _service.UpdatePersonAsync(entity, key); return(Ok()); }
public void Update_BadRequest() { var model = new UpdatePersonModel(0, "Frodo", "The Shire"); var result = _controller.Put(model); Assert.IsInstanceOf <BadRequestObjectResult>(result.Result); }
public Domain.Entities.Person Map(UpdatePersonModel source) { return(new Domain.Entities.Person { Age = source.Age, Name = source.Name }); }
public async Task <ActionResult <PersonModel> > UpdatePerson(UpdatePersonModel request) { var uid = new Guid(HttpContext.Request.Headers[AuthorizationHeaders.PersonUid].First()); var validationResult = _personValidation.ValidateUpdatePerson(request, uid); if (!validationResult.ValidationResult) { return(BadRequest(validationResult.ValidationMessage)); } return(await _personLogic.UpdatePerson(request, uid)); }
public async Task <IActionResult> Put(UpdatePersonModel data) { if (data.Id == 0) { return(BadRequest()); } await _data.UpdatePerson(data.Id, data.FirstName); return(Ok()); }
public async Task <IActionResult> Edit(int id) { var data = await _data.GetPersonById(id); var person = new UpdatePersonModel { Id = id, FirstName = data.FirstName }; return(View(person)); }
private IPersonForResponse CreateModelForPutTest() { var model = new UpdatePersonModel { FirstName = "Create", Surname = "Test", DateOfBirth = "1/01/2001", Sex = "M", Email = "Email" }; return(model); }
public async Task <int> UpdatePerson(UpdatePersonModel model) { try { _dbconnection.StoredProcedure = Constants.UpdatePeopleDetailsStoredProcedure; _dbconnection.Parameters = model; return(await _dapperRepository.Execute(_dbconnection)); } catch (Exception ex) { throw ex; } }
public async Task <ActionResult> Update(int id, [FromBody] UpdatePersonModel model) { PersonManagement personManagement = new PersonManagement(); await personManagement.Find(id); model.Map(personManagement.Person); if (!await personManagement.Update()) { return(new PersonErrorJson(personManagement)); } return(new HttpStatusCodeResult(HttpStatusCode.NoContent)); }
public void Update_Ok() { var model = new UpdatePersonModel(1, "Frodo", "The Shire"); var result = _controller.Put(model); Assert.IsInstanceOf <OkObjectResult>(result.Result); var value = (result.Result as OkObjectResult).Value as Person; Assert.AreEqual(1, value.Id); Assert.AreEqual("Frodo", value.Name); Assert.AreEqual("The Shire", value.Nationality); }
public static void UpdatePerson(Person person, UpdatePersonModel model) { person.FirstName = model.FirstName; person.PreferredFirstName = model.PreferredFirstName; person.LastName = model.LastName; person.PreferredLastName = model.PreferredLastName; person.MiddleName = model.MiddleName; person.Title = model.Title; person.NhsNumber = model.NhsNumber; person.Gender = model.Gender; person.Dob = model.Dob; person.EthnicityId = model.EthnicityId; person.Deceased = model.Deceased; person.PhotoId = model.PhotoId; }
private IPersonForResponse CreateModelForUpdate(dynamic person) { int id = Convert.ToInt32(person ["Id"].Value); var model = new UpdatePersonModel { Id = id, FirstName = "FirstName Update", Surname = "Surname Update", DateOfBirth = "11/11/2011", Sex = "F", Email = "Email Updated" }; return(model); }
public async Task <IActionResult> UpdatePerson([FromRoute] Guid id, [FromBody] UpdatePersonModel updatePerson) { var person = await _persons.GetByIdAsync(id).ConfigureAwait(false); if (person == null) { return(NotFound()); } var entity = _mapper.Map <PersonEntity>(updatePerson); entity.Id = id; await _persons.UpdateAsync(entity).ConfigureAwait(false); return(NoContent()); }
public async Task <JsonResult> UpdatePerson(UpdatePersonModel person) { if (person.PersonId == Guid.Empty) { return(Json(false, JsonRequestBehavior.AllowGet)); } var result = await _personOrchestrator.UpdatePerson(new PersonViewModel { PersonId = person.PersonId, FirstName = person.FirstName, LastName = person.LastName, Gender = person.Gender, Email = person.Email, PhoneNumber = person.PhoneNumber }); return(Json(result, JsonRequestBehavior.AllowGet)); }
public async Task <JsonResult> UpdatePerson(UpdatePersonModel person) { var sesId = (string)Session["LoginId"]; if (person.PersonId == Guid.Empty) { return(Json(false, JsonRequestBehavior.AllowGet)); } var result = await _personOrchestrator.UpdatePersonAsync(new PersonViewModel { PersonId = new Guid(sesId), FirstName = person.FirstName, LastName = person.LastName, Gender = person.Gender, Email = person.Email, PhoneNumber = person.PhoneNumber }); return(Json(result, JsonRequestBehavior.AllowGet)); }
public void UpdatePerson(UpdatePersonModel person) { ThrowExceptionIfGuidIsEmpty(person.Id); var personModel = _persons.SingleOrDefault(x => x.Id == person.Id); if (personModel == null) { return; } if (person.Age.HasValue) { personModel.Age = person.Age.Value; } if (string.IsNullOrEmpty(person.Name)) { personModel.Name = person.Name; } }
public PersonModel?UpdatePerson(UpdatePersonModel patch) { using var ctx = _contextFactory.CreateDbContext(); var person = ctx.People.FirstOrDefault(o => o.Id == patch.Id); if (person is null) { return(null); } person.Name = patch.Name; try { ctx.SaveChanges(); return(person.ToPersonModel()); } catch (Exception e) { _logger.LogError(e, $"Failed to update person by ID '{patch.Id}' in database."); return(null); } }
public ActionResult UpdateDetails(UpdatePersonModel model) { if (ModelState.IsValid) { var identity = User.Identity.Name; var count = db.Registered_Person.Count(me => me.Person_Email == model.Person_Email && me.Person_ID != identity); if (count == 0) { var registered_Person = (from a in db.Registered_Person where a.Person_ID == identity select a).FirstOrDefault(); registered_Person.Person_Name = model.Person_Name; registered_Person.Person_Surname = model.Person_Surname; registered_Person.Person_Email = model.Person_Email; db.Entry(registered_Person).State = EntityState.Modified; db.SaveChanges(); //record action global.addAudit("Students", "Students: Update Profile", "Update", User.Identity.Name); TempData["Message"] = "Details successfully updated!"; TempData["classStyle"] = "success"; return(RedirectToAction("Details")); } else { TempData["Message"] = "Email address already exists on the system"; return(View(model)); } } return(View(model)); }
public async Task <IActionResult> Edit(UpdatePersonModel person) { await _data.UpdatePerson(person.Id, person.FirstName); return(RedirectToAction("Index")); }
public (bool ValidationResult, string ValidationMessage) ValidateUpdatePerson(UpdatePersonModel model, Guid personUid) { if (model.Name != null && string.IsNullOrWhiteSpace(model.Name)) { return(false, ErrorDictionary.GetErrorMessage(51, _culture)); } if (!_personRepository.CheckPersonExistence(personUid).Result) { return(false, ErrorDictionary.GetErrorMessage(2, _culture)); } if (!string.IsNullOrEmpty(model.Login) && _personRepository.CheckPersonExistence(personUid, model.Login).Result) { return(false, ErrorDictionary.GetErrorMessage(33, _culture)); } if (model.Age.HasValue && model.Age.Value < 14) { return(false, ErrorDictionary.GetErrorMessage(43, _culture)); } if (model.CityId.HasValue) { var cities = _cityLogic.GetCities().Result; if (!cities.Any(x => x.CityId == model.CityId.Value)) { return(false, ErrorDictionary.GetErrorMessage(30, _culture)); } } if (model.Image == null ^ model.MiniImage == null) { return(false, ErrorDictionary.GetErrorMessage(52, _culture)); } return(true, string.Empty); }
public async Task <PersonModel> UpdatePerson(UpdatePersonModel updatePersonModel, Guid personUid) { var entity = await _personRepository.GetPerson(personUid); if (!string.IsNullOrEmpty(updatePersonModel.Name)) { entity.Name = updatePersonModel.Name; } if (!string.IsNullOrEmpty(updatePersonModel.Description)) { entity.Description = updatePersonModel.Description; } if (updatePersonModel.Age.HasValue) { entity.Age = updatePersonModel.Age; } if (updatePersonModel.CityId.HasValue) { entity.CityId = updatePersonModel.CityId; } if (!string.IsNullOrEmpty(updatePersonModel.Login)) { entity.Login = updatePersonModel.Login; } if (string.IsNullOrWhiteSpace(entity.Login) && string.IsNullOrWhiteSpace(updatePersonModel.Login)) { entity.Login = await GenarateLogin(updatePersonModel.Name); } if (updatePersonModel.Token != null) { entity.Token = updatePersonModel.Token; await _personRepository.RemoveTokenForEveryPerson(updatePersonModel.Token); } var deleteOldImage = false; var imageToDelete = entity.PersonImageContentEntity; if (updatePersonModel.Image != null) { deleteOldImage = entity.PersonImageContentEntity != null; var imageUid = await _imageLogic.SaveImage(updatePersonModel.Image); var miniImageUid = await _imageLogic.SaveImage(updatePersonModel.MiniImage); entity.PersonImageContentEntity = new PersonImageContentEntity { PersonImageContentUid = imageUid, PersonMiniatureImageContentUid = miniImageUid }; } else { entity.PersonImageContentEntity = null; } var model = _mapper.Map <PersonModel>(entity); entity.FriendList = null; entity.City = null; entity.SwipeHistory = null; await _personRepository.UpdatePerson(entity); if (deleteOldImage) { await _personRepository.RemovePersonImage(imageToDelete); await _imageLogic.RemoveImage(imageToDelete.PersonImageContentUid); if (imageToDelete.PersonMiniatureImageContentUid.HasValue) { await _imageLogic.RemoveImage(imageToDelete.PersonMiniatureImageContentUid.Value); } } return(model); }
public async Task <ActionResult <ResponseModel> > UpdatePerson([FromBody] UpdatePersonModel model) { var result = await _adminService.UpdatePerson(model); return(ResponseUtility.CreateResponse(result)); }
public async Task <Person> Update(UpdatePersonModel club) { throw new System.NotImplementedException(); }