public async Task <User> Update(UserUpdateViewModel updateUser)
{
User existingUser = await _userRepository.GetById(updateUser.Id);
if (existingUser == null)
{
return(null);
}
return(await _userRepository.Update(
_mapper.Map <User>(updateUser)));
}
public async Task <IActionResult> Update([FromBody] UserUpdateViewModel model)
{
User user = mapper.Map <User>(model);
Response response = await userService.Update(user);
if (response.Success)
{
return(Json(new { Sucesso = true }));
}
return(View("Index"));
}
public async Task <IActionResult> Update([FromRoute] int userId, [FromBody] UserUpdateViewModel user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ApplicationRole dbRole = null;
if (user.RoleId.HasValue)
{
dbRole = await _roleManager.FindByIdAsync(user.RoleId.ToString());
if (dbRole is null)
{
ModelState.AddModelError(nameof(user.RoleId), "Invalid role id.");
return(BadRequest(ModelState));
}
}
var dbUser = await _userManager.FindByIdAsync(userId.ToString());
dbUser.UserName = user.UserName;
dbUser.Email = user.Email;
dbUser.ConcurrencyStamp = user.ConcurrencyStamp;
var identityResult = await _userManager.UpdateAsync(dbUser);
if (!identityResult.Succeeded)
{
return(BadRequest(identityResult.Errors));
}
if (!string.IsNullOrWhiteSpace(user.Password))
{
await _userManager.RemovePasswordAsync(dbUser);
await _userManager.AddPasswordAsync(dbUser, user.Password);
}
if (dbRole != null)
{
var roleNames = await _userManager.GetRolesAsync(dbUser);
await _userManager.RemoveFromRolesAsync(dbUser, roleNames);
await _userManager.AddToRoleAsync(dbUser, dbRole.Name);
}
return(Ok(dbUser.ToViewModel()));
}
public async Task <IActionResult> Update(UserUpdateViewModel model)
{
if (ModelState.IsValid)
{
UserDTO userDTO = Mappers.MapUserUpdateVMToUserDTO(model);
if (userDTO.DateOfBirth?.Date == DateTime.Now.Date)
{
userDTO.DateOfBirth = null;
}
_userService.UpdateUserAccountData(userDTO);
return(RedirectToAction("Index", "Home"));
}
return(View(model));
}
public async Task <User> UpdateAsync(User user, UserUpdateViewModel vm)
{
user.Username = vm.Username ?? user.Username;
user.Email = vm.Email ?? user.Email;
user.Bio = vm.Bio ?? user.Bio;
user.Forename = vm.Forename ?? user.Forename;
user.Surname = vm.Surname ?? user.Surname;
user.DateOfBirth = vm.DateOfBirth ?? user.DateOfBirth;
_context.Users.Update(user);
await _context.SaveChangesAsync();
return(user);
}
public IActionResult UserUpdate(UserUpdateViewModel userUpdateViewModel)
{
if (!ModelState.IsValid)
{
return(View());
}
var user = _context.appUsers.FirstOrDefault(x => x.Id == userUpdateViewModel.Id);
user.UserName = userUpdateViewModel.UserName;
user.Gender = userUpdateViewModel.Gender;
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Update(string name)
{
if (name != null)
{
User user = await _userManager.FindByEmailAsync(name);
if (user.Id != CurrentUserId)
{
return(BadRequest());
}
UserUpdateViewModel userUpdateViewModel = Mappers.MapUserToUserUpdateVM(user);
userUpdateViewModel.AvatarPath = _fileService.GetAvatarPath(CurrentUserId);
return(View(userUpdateViewModel));
}
return(NotFound());
}
public ActionResult Update(User user, UserUpdateCommand userUpdateCommand, User currentUser)
{
Require.NotNull(user, "user");
Require.NotNull(userUpdateCommand, "userUpdateCommand");
/*Wenn ein neues Passwort eingetragen wurde und valide ist, dann wird es übernommen.*/
string passwordHash = user.PasswordHash;
if (!string.IsNullOrWhiteSpace(userUpdateCommand.NewPassword))
{
/*neues Passwort validieren*/
IdentityResult identityResult = UserManager.PasswordValidator.ValidateAsync(userUpdateCommand.NewPassword).Result;
if (identityResult.Succeeded)
{
/*Passwort-Hash erstellen*/
passwordHash = UserManager.PasswordHasher.HashPassword(userUpdateCommand.NewPassword);
}
else
{
/*Fehler am Model-State hinterlegen, damit die Update-Routine abgebrochen wird und eine Fehlermeldung auf dem Formular angezeigt wird*/
AddErrors(identityResult, "Password");
}
}
if (ModelState.IsValid)
{
/*Wenn alle Eingaben valide sind, dann Nutzer aktualisieren*/
UserService.Update(user,
passwordHash,
userUpdateCommand.UserContactDto,
userUpdateCommand.UserDataDto,
userUpdateCommand.UserPaymentDto,
userUpdateCommand.UserNotificationOptionsDto,
userUpdateCommand.UserPermissionDto,
userUpdateCommand.NewDocuments,
userUpdateCommand.DeleteDocuments,
new EntityChangedDto(currentUser, DateTime.Now));
return(RedirectToAction("Index", "UserAdministration"));
}
/*andernfalls Formular wieder anzeigen*/
IList <string> roles = Roles.AllRoles;
IList <UserGroup> financialBrokerPools = UserGroupService.GetAll();
UserUpdateViewModel userUpdateViewModel = new UserUpdateViewModel(user, roles, financialBrokerPools, userUpdateCommand);
return(View(userUpdateViewModel));
}
public HttpResponseMessage UpdateUser([FromBody] UserUpdateViewModel model)
{
Usuario user = db.Usuario.FirstOrDefault(s => s.id == model.Id);
var json = "";
try
{
user.nombre = model.Name;
user.apellido1 = model.MidleName;
user.apellido2 = model.LastName;
user.telefono = model.Telefono;
user.email = model.Correo;
db.SaveChanges();
json = Helper.toJson(true, "Usuario Actualizado");
return(new HttpResponseMessage()
{
Content = new StringContent(json.ToString(), Encoding.UTF8, "application/json")
});
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
//Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",ve.PropertyName, ve.ErrorMessage);
EventLog eventLog = new EventLog("Application");
eventLog.Source = "BonaterraSite";
eventLog.WriteEntry("- Property: " + ve.PropertyName + ", Error: " + ve.ErrorMessage, EventLogEntryType.Information, 101, 1);
}
json = Helper.toJson(false, "No se pudo actualizar usuario");
return(new HttpResponseMessage()
{
Content = new StringContent(json.ToString(), Encoding.UTF8, "application/json")
});
}
throw;
}
}
public IActionResult UserUpdate(int Id)
{
var user = _context.appUsers.FirstOrDefault(x => x.Id == Id);
if (user == null)
{
return(RedirectToAction(nameof(Index)));
}
UserUpdateViewModel userUpdateViewModel = new UserUpdateViewModel()
{
Id = user.Id,
UserName = user.UserName,
Gender = user.Gender
};
return(View(userUpdateViewModel));
}
public async Task <JsonResult> UpdateProfile([FromBody] UserUpdateViewModel model)
{
var user = await _userManager.FindByIdAsync(this.GetUserId());
user.UserName = model.DisplayName;
user.Email = model.Email;
user.PhoneNumber = model.Phone;
var r = await _userManager.UpdateAsync(user);
if (r.Succeeded)
{
return(returnUser(user));
}
throw new ApplicationException($"Unable to update user with ID [{GetUserId()}].");
}
public IActionResult EditUser(UserUpdateViewModel model)
{
var user = userService.FindByCondition(p => p.Id == model.UserId).FirstOrDefault();
if (user == null)
{
throw new Exception("No user exists with this email");
}
var userRole = roleService.FindByCondition(p => p.Id == model.RoleId).FirstOrDefault();
user.Email = model.Email;
user.UserName = model.FullName;
user.RoleId = userRole.Id;
userService.UpdateUser(user);
return(RedirectToAction("UsersList"));
}
public async Task <IActionResult> Update(long userId)
{
try
{
var roleManager = serviceProvider.GetRequiredService <RoleManager <Role> >();
var userService = serviceProvider.GetRequiredService <IUserService>();
var roles = roleManager.Roles.Select(x => new SelectListItem {
Text = x.Name, Value = x.NormalizedName
}).ToList();
var user = await userService.GetUser(userId);
ViewData["UserDetail"] = user;
var userRoles = await serviceProvider.GetRequiredService <UserManager <User> >().GetRolesAsync(user);
var model = new UserUpdateViewModel
{
FirstName = user.FirstName,
LastName = user.LastName,
Phone = user.PhoneNumber,
RoleName = userRoles.FirstOrDefault(),
Email = user.Email
};
roles.Insert(0, new SelectListItem {
Text = "Select Role", Value = ""
});
model.Role = roles;
return(View(model));
}
catch (KeyNotFoundException ex)
{
logger.LogError(ex.Message, ex);
return(BadRequest());
}
catch (Exception ex)
{
logger.LogError(ex.Message, ex);
return(BadRequest());
}
}
public async Task <IActionResult> UpdateUser(int id, [FromBody] UserUpdateViewModel viewModel)
{
if (viewModel == null)
{
return(Ok(new BaseResponse()
{
success = false, message = "提交的数据有误!"
}));
}
try
{
var user = await repository.GetUserByIdAsync(id);
if (user == null)
{
return(Ok(new BaseResponse()
{
success = false, message = "未能找到该用户信息!"
}));
}
mapper.Map(viewModel, user);
if (!await work.SaveAsync())
{
return(Ok(new BaseResponse()
{
success = false, message = $"Updating post {id} failed when saving."
}));
}
return(Ok(new BaseResponse()
{
success = true
}));
}
catch (Exception ex)
{
return(Ok(new BaseResponse()
{
success = false, message = ex.Message
}));
}
}
public async Task <ActionResult <UserViewModel> > UpdateUser(UserUpdateViewModel updateViewModel)
{
if (updateViewModel == null)
{
return(BadRequest());
}
User foundUser = await UserService.GetUser(updateViewModel.Id);
if (foundUser == null)
{
return(NotFound());
}
Mapper.Map(updateViewModel, foundUser);
await UserService.UpdateUser(foundUser);
return(NoContent());
}
