public IActionResult Index(AppUserUpdateModel model)
{
TempData["active"] = "bilgilerim";
if (ModelState.IsValid)
{
var updatedAppUser = appUserService.GetById(model.Id);
if (model.Picture != null)
{
var imgName = Guid.NewGuid() + Path.GetExtension(model.Picture.FileName);
var path = Directory.GetCurrentDirectory() + "/wwwroot/img/" + imgName;
var stream = new FileStream(path, FileMode.Create);
model.Picture.CopyTo(stream);
updatedAppUser.ImageUrl = imgName;
}
updatedAppUser.LastName = model.LastName;
updatedAppUser.FirstName = model.FirstName;
updatedAppUser.PhoneNumber = model.PhoneNumber;
updatedAppUser.ShortDescription = model.ShortDescription;
updatedAppUser.Address = model.Address;
updatedAppUser.Email = model.Email;
appUserService.Update(updatedAppUser);
TempData["message"] = "İşleminiz başarıyla gerçekleşti";
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public async Task <AppUserUpdateModel> Update(string id, AppUserUpdateModel user)
{
try
{
var updateUser = await _userManager.FindByIdAsync(id);
updateUser.LastName = user.LastName;
updateUser.FirstName = user.FirstName;
updateUser.Email = user.Email;
updateUser.UpdatedDate = CoreHelper.SystemTimeNowUTCTimeZoneLocal;
await _userManager.UpdateAsync(updateUser);
var claims = await _userManager.GetClaimsAsync(updateUser);
await _userManager.RemoveClaimsAsync(updateUser, claims);
foreach (var item in user.Claims)
{
_userManager.AddClaimAsync(updateUser, new Claim(item.ClaimName, item.ClaimValue)).Wait();
}
return(user);
}
catch
{
throw;
}
}
public async Task <IActionResult> Update(string username, [FromForm] AppUserUpdateModel updateModel)
{
if (string.IsNullOrEmpty(username))
{
return(BadRequest());
}
if (User.GetUsername() != username)
{
return(Unauthorized());
}
var user = await _userService.GetUserAsync(username);
if (user == null)
{
return(NotFound($"User {username} does not exist"));
}
var result = await _accountService.UpdateAsync(user, updateModel);
if (result.Success)
{
return(NoContent());
}
ModelState.AddModelErrors(result.Errors);
return(BadRequest(new ValidationResultModel(ModelState)));
}
public async Task <IActionResult> Update(string id, AppUserUpdateModel user)
{
if (ModelState.IsValid)
{
var updateUser = await _userIdentityService.Update(id, user);
}
return(Ok());
}
public async Task <PayloadResult <AppUser> > UpdateUserAsync(AppUser user, AppUserUpdateModel model)
{
var userToUpdate = await _userManager.Users.FirstOrDefaultAsync(x => x.UserName == user.UserName);
if (userToUpdate == null)
{
return new PayloadResult <AppUser>
{
Errors = new[] { $"User with username '{user.UserName}' does not exists." }
}
}
;
if (model.Name != null)
{
user.Name = model.Name;
}
if (model.Lastname != null)
{
user.Lastname = model.Lastname;
}
if (model.Email != null)
{
user.Email = model.Email;
}
if (model.PhoneNumber != null)
{
user.PhoneNumber = model.PhoneNumber;
}
await _userManager.UpdateAsync(user);
var update = await _dataContext.SaveChangesAsync() > 0;
if (!update)
{
return new PayloadResult <AppUser>
{
Errors = new[] { $"Could not save changes." },
Success = false
}
}
;
return(new PayloadResult <AppUser>
{
Payload = user
});
}
public IActionResult Index()
{
TempData["active"] = "bilgilerim";
var user = appUserService.FindByName(User.Identity.Name);
var appUserUpdateModel = new AppUserUpdateModel
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
Address = user.Address,
PhoneNumber = user.PhoneNumber,
ShortDescription = user.ShortDescription,
ImageUrl = user.ImageUrl
};
return(View(appUserUpdateModel));
}
public IActionResult Index()
{
var user = _appUserService.GetByUserName(User.Identity.Name);
TempData["Active"] = "bilgilerim";
var model = new AppUserUpdateModel
{
FirstName = user.FirstName,
LastName = user.LastName,
Adress = user.Adress,
Id = user.Id,
ShortDescription = user.ShortDescription,
Email = user.Email,
ImageUrl = user.ImageUrl,
PhoneNumber = user.PhoneNumber
};
return(View(model));
}
public async Task <BaseRequestResult> UpdateAsync(AppUser user, AppUserUpdateModel updateModel)
{
if (updateModel.NewPassword != null)
{
var passwordChangeResult = await _userManager.ChangePasswordAsync(user, updateModel.CurrentPassword, updateModel.NewPassword);
if (!passwordChangeResult.Succeeded)
{
return(new BaseRequestResult
{
Errors = passwordChangeResult.Errors.ToDictionary(x => "CurrentPassword", y => y.Description)
});
}
}
if (updateModel.ProfilePicture != null)
{
var uploadedFilePath = await ImageUtilities.ProcessUploadedFile(updateModel.ProfilePicture, _imageSettings.ProfilePicture.Location,
_imageSettings.ProfilePicture.Format, _imageSettings.ProfilePicture.Width, _imageSettings.ProfilePicture.Height);
user.ProfilePicture = uploadedFilePath;
}
user.Email = updateModel.Email;
user.FirstName = updateModel.FirstName;
user.LastName = updateModel.LastName;
user.IsRealNameHidden = updateModel.IsRealNameHidden;
user.Description = updateModel.Description;
var identityResult = await _userManager.UpdateAsync(user);
return(identityResult.Succeeded ? new BaseRequestResult
{
Success = true
} : new BaseRequestResult
{
Success = false,
Errors = identityResult.Errors.ToDictionary(x => x.Code, y => y.Description)
});
}
public async Task <IActionResult> Update(string username, [FromForm] AppUserUpdateModel model)
{
if (string.IsNullOrEmpty(username))
{
return(BadRequest());
}
if (ActionResult(username, out var unauthorized))
{
return(unauthorized);
}
var user = await _userService.GetUserByNameAsync(username);
if (user == null)
{
return(NotFound("Such user does not exists."));
}
await _userService.UpdateUserAsync(user, model);
return(Ok());
}
