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