public async Task <UserProfileResponseModel> Edit(UserProfileRequestModel userProfileRequestModel)
{
var salt = CreateSalt();
var dbUser = await _userRepository.GetUserByEmail(userProfileRequestModel.Email);
var user = new User()
{
Id = userProfileRequestModel.Id,
Email = userProfileRequestModel.Email,
FirstName = userProfileRequestModel.FirstName == null ? dbUser.FirstName : userProfileRequestModel.FirstName,
LastName = userProfileRequestModel.LastName == null ? dbUser.LastName : userProfileRequestModel.LastName,
Salt = userProfileRequestModel.Password == null ? dbUser.Salt : salt,
HashedPassword = userProfileRequestModel.Password == null ? dbUser.HashedPassword :
CreateHashedPassword(userProfileRequestModel.Password, salt),
PhoneNumber = userProfileRequestModel.PhoneNumber == null ? dbUser.PhoneNumber : userProfileRequestModel.PhoneNumber,
};
var updatedUser = await _userRepository.UpdateAsync(user);
var updatedUserResponse = new UserProfileResponseModel
{
Id = updatedUser.Id,
Email = updatedUser.Email,
FirstName = updatedUser.FirstName,
LastName = updatedUser.LastName
};
return(updatedUserResponse);
// return await _userRepository.UpdateAsync(user);
}
public async Task <IActionResult> EditProfile(UserProfileRequestModel model)
{
if (ModelState.IsValid)
{
await _userService.EditUser(model);
}
return(LocalRedirect("~/Account/Login"));
}
public async Task UpdateUserProfileAsync(UserProfileRequestModel requestModel)
{
ApplicationUser user = await _userRepository.GetByIdAsync(requestModel.Id);
user = requestModel.MapToEntity(user);
await _userRepository.UpdateAsync(user);
}
public async Task <Uri> UploadUserProfilePicture(UserProfileRequestModel userProfileRequestModel)
{
_blobService.ContainerName = "userimagescontainer";
var result = await _blobService.UploadFileBlobAsync(userProfileRequestModel.File.OpenReadStream(),
userProfileRequestModel.File.ContentType, userProfileRequestModel.File.FileName);
return(result);
}
public async Task <IActionResult> EditProfile(UserProfileRequestModel userRequestModel)
{
// call user service and map the UserRequestModel data into User entity and call repository
userRequestModel.Id = (int)_currentUserService.UserId;
userRequestModel.Email = _currentUserService.Email;
var newUser = await _userService.Edit(userRequestModel);
return(View(newUser));
}
public async Task <IActionResult> Upload(IFormFile profileImage)
{
var userProfile = new UserProfileRequestModel()
{
Id = _currentUserService.UserId.Value,
FullName = _currentUserService.FullName,
File = profileImage
};
var response = _userService.UploadUserProfilePicture(userProfile);
return(View());
}
public async Task <IActionResult> EditProfile(UserProfileRequestModel model)
{
// check if user already logged in
if (User.Identity != null && User.Identity.IsAuthenticated)
{
if (ModelState.IsValid)
{
//save to database
var user = await _userService.EditUserProfile(model, _currentUserService.UserId);
// redirect to Login
return(RedirectToAction("Logout"));
}
}
return(View());
}
public async Task <UserProfileResponseModel> EditProfileAsync(int id, UserProfileRequestModel model)
{
var user = _unitOfWork.Repository <ApplicationUser>().Get(w => w.Id == id && (_userId == id || (!w.UserRoles.Any(x => x.Role.Name == Role.SuperAdmin) && (!w.UserRoles.Any(x => x.Role.Name == Role.Admin) || _isUserSuperAdmin))))
.TagWith(nameof(EditProfileAsync) + "_GetUser")
.Include(w => w.Profile)
.ThenInclude(w => w.Avatar)
.FirstOrDefault();
if (user == null)
{
return(null);
}
else if (user.Profile == null)
{
user.Profile = new Profile();
}
_mapper.Map(model, user.Profile);
// If user pass avatar id - attach it to profile
if (model.ImageId.HasValue)
{
AddAvatar(user, model.ImageId.Value);
}
else if (user.Profile.Avatar != null && !model.ImageId.HasValue)
{
// If user have avata but in model - null
await _imageService.RemoveImage(user.Profile.AvatarId.Value);
user.Profile.Avatar = null;
}
_unitOfWork.Repository <ApplicationUser>().Update(user);
_unitOfWork.SaveChanges();
return(_mapper.Map <UserProfileResponseModel>(user.Profile));
}
public async Task EditUser(UserProfileRequestModel userProfileRequestModel)
{
//var salt = CreateSalt();
//var hashedPassword = CreateHashedPassword(userProfileRequestModel.Password, salt);
var currentUser = await _userRepository.GetUserbyEmail(_currentUserService.Email);
var inputUser = new User
{
FirstName = userProfileRequestModel.FirstName,
LastName = userProfileRequestModel.LastName,
Email = userProfileRequestModel.Email,
DateOfBirth = userProfileRequestModel.DateOfBirth,
//Salt = salt,
//HashedPassword = hashedPassword
};
currentUser.FirstName = inputUser.FirstName;
currentUser.LastName = inputUser.LastName;
currentUser.Email = inputUser.Email;
currentUser.DateOfBirth = inputUser.DateOfBirth;
await _userRepository.Update(currentUser);
}
public async Task <UserProfileResponseModel> EditUserProfile(UserProfileRequestModel userProfileRequestModel, int id)
{
var dbUser = await _userRepository.GetUserById(id);
if (dbUser == null)
{
throw new Exception("User does not exist");
}
dbUser.FirstName = userProfileRequestModel.FirstName;
dbUser.LastName = userProfileRequestModel.LastName;
dbUser.Email = userProfileRequestModel.Email;
var updatedUser = await _userRepository.Update(dbUser);
var response = new UserProfileResponseModel
{
Id = updatedUser.Id,
Email = updatedUser.Email,
FullName = updatedUser.FirstName + " " + updatedUser.LastName,
};
return(response);
}
public async Task UpdateUserProfile(UserProfileRequestModel requestModel)
{
await _userService.UpdateUserProfileAsync(requestModel);
}
public Task <UserProfileModel> GetUserProfile(UserProfileRequestModel userRequested)
{
throw new NotImplementedException();
}
