public async Task <IActionResult> Edit(string username, UserEditServiceModel model)
{
if (username.ToLower() != User.Identity.Name.ToLower())
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(model));
}
ICollection <IdentityError> errors = await this.userService.Edit(username, model.Email, model.OldPassword, model.NewPassword, model.Phone);
if (errors.Any())
{
foreach (IdentityError error in errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View(model));
}
return(RedirectToAction(nameof(Profile), new { username = username }));
}
public async Task EditUserAsync(string userId, UserEditServiceModel model)
{
var user = await this.db.Users.FindAsync(userId);
if (user == null)
{
throw new ArgumentException("user doesn't exist");
}
this.mapper.Map(model, user);
this.db.Update(user);
await this.db.SaveChangesAsync();
}
public void Edit_ShouldReturnValidViewWithCorrectDataForCurrentUser()
{
//Arrange
var userIdValue = "userId";
var pictureUrl = "picture";
var expectedUser = new UserEditServiceModel
{
UserName = "******",
Address = "test",
AdditionalInformation = "testing here"
};
var userManager = UserManagerMock.New;
userManager
.Setup(um => um.GetUserId(It.IsAny <ClaimsPrincipal>()))
.Returns(userIdValue);
var userService = UserServiceMock.New;
userService
.Setup(us => us.GetForEdit(It.Is <string>(userId => userId == userIdValue)))
.Returns(expectedUser);
var pictureService = PictureServiceMock.New;
pictureService
.Setup(ps => ps.PreparePictureToDisplay(It.IsAny <string>()))
.Returns(pictureUrl);
var controller = new UsersController(userService.Object, null, pictureService.Object, userManager.Object);
//Act
var result = controller.Edit();
//Assert
result
.Should()
.BeOfType <ViewResult>()
.Subject
.Model
.Should()
.Match(m => m.As <UserEditViewModel>().FormDataModel == expectedUser &&
m.As <UserEditViewModel>().ProfilePictureUrl == pictureUrl);
}
public void Edit(UserEditServiceModel userModel, User user)
{
user.Email = userModel.Email;
user.UserName = userModel.UserName;
if (userModel.Role != null && userModel.Role.Count() > 0)
{
var allRoles = OrfeaBGRoles();
foreach (var role in allRoles)
{
if (userModel.Role.Contains(role.Text))
{
Task
.Run(async() =>
{
await userManager.AddToRoleAsync(user, role.Text);
}).Wait();
}
else
{
Task
.Run(async() =>
{
await userManager.RemoveFromRoleAsync(user, role.Text);
}).Wait();
}
}
}
if (userModel.Password != null)
{
Task
.Run(async() =>
{
await this.userManager.ChangePasswordAsync(user, user.PasswordHash, userModel.Password);
}).Wait();
}
Task
.Run(async() =>
{
await this.userManager.UpdateAsync(user);
}).Wait();
}
public async Task <IActionResult> Edit(UserEditServiceModel user)
{
if (!ModelState.IsValid)
{
return(View(user));
}
var userForEdit = await this.userManager.FindByIdAsync(user.Id);
if (userForEdit == null)
{
return(BadRequest());
}
this.users.Edit(user, userForEdit);
TempData[WebConstants.TempDataSuccessMessageKey] = ($"User {userForEdit.UserName} successfully updated.");
return(RedirectToAction(nameof(Users)));
}
public async Task <IActionResult> Edit(UserEditServiceModel userModel)
{
if (!ModelState.IsValid)
{
this.TempData.AddFailureMessage(string.Format(FailureAddItemMessage, userModel.UserName));
return(this.RedirectToAction(nameof(Index)));
//return this.View(userModel);
}
var userDetail = await this.usersService.GetByIdAsync <UserEditServiceModel>(userModel.Id);
if (userDetail == null)
{
return(this.NotFound());
}
await this.usersService.EditUserAsync(userModel.Id, userModel);
this.TempData.AddSuccessMessage(string.Format(SuccessEditItemMessage, userModel.UserName));
return(RedirectToAction(nameof(Index)));
}
public IActionResult Edit(string username)
{
if (username.ToLower() != User.Identity.Name.ToLower())
{
return(NotFound());
}
if (string.IsNullOrEmpty(username))
{
return(NotFound());
}
UserEditServiceModel model = this.userService.GetUserEditDetailsByUsername(username);
if (model == null)
{
return(NotFound());
}
return(this.View(model));
}
