public UpdateUser GetUser(int Id)
{
UpdateUser userData = new UpdateUser();
string connStr = WebConfigurationManager.ConnectionStrings["tdlConnection"].ToString();
using (SqlConnection conn = new SqlConnection(connStr))
{
string query = "SELECT * FROM Users WHERE user_id = @Id";
using (SqlCommand cmd = new SqlCommand(query, conn)){
conn.Open();
cmd.Parameters.AddWithValue("@Id", Id);
SqlDataReader reader = cmd.ExecuteReader();
reader.Read();
userData.user_id = Convert.ToInt16(reader["user_id"]);
userData.first_name = Convert.ToString(reader["first_name"]);
userData.last_name = Convert.ToString(reader["last_name"]);
userData.email = Convert.ToString(reader["email"]);
userData.password = Convert.ToString(reader["password"]);
}
}
return(userData);
}
public void Handle(UpdateUser update)
{
if (update.User.Id == CacheService.Options.MyId)
{
_lifetimeService.Update();
}
}
public void should_update_an_existing_user()
{
var existingUser = new User();
Save(existingUser);
var updateUser = new UpdateUser
{
Id = existingUser.Id,
Username = "******",
EmailAddress = "f",
Name = "fo",
Password = "******",
};
User user = null;
WithDbContext(context => user = GetInstance<UpdateUserHandler>().Handle(updateUser));
WithDbContext(context =>
{
var foundUser = context.Find<User>(user.Id);
foundUser.ShouldNotBeNull();
Compare(foundUser, user);
});
}
private static async Task AttemptUpdateDuplicate(
HttpClient client,
string token)
{
var command = new UpdateUser(
null,
new UserUpdate(Username: UniqueUsername));
await SendCommand(
client,
command,
"/api/user",
method : HttpMethod.Put,
headers : new Dictionary <string, string>
{
{ "Authorization", $"Bearer {token}" }
},
expectedResponseCode : HttpStatusCode.Conflict);
command = new UpdateUser(null, new UserUpdate(Email: UniqueEmail));
await SendCommand(
client,
command,
"/api/user",
method : HttpMethod.Put,
headers : new Dictionary <string, string>
{
{ "Authorization", $"Bearer {token}" }
},
expectedResponseCode : HttpStatusCode.Conflict);
}
public void should_create_a_new_user()
{
var updateUser = new UpdateUser
{
Username = "******",
EmailAddress = "f",
Name = "fo",
Password = "******"
};
User user=null;
WithDbContext(context => user= GetInstance<UpdateUserHandler>().Handle(updateUser));
WithDbContext(context =>
{
var foundUser = context.Find<User>(user.Id);
foundUser.ShouldNotBeNull();
var compare = new KellermanSoftware.CompareNetObjects.CompareObjects();
// savedJob is a proxy
compare.MaxDifferences = 1;
compare.Compare(user, foundUser);
});
}
private static void ApplyUpdateToModel(UpdateUser request, IUserAuth updated)
{
updated.UserName = request.UserName;
updated.DisplayName = request.DisplayName;
updated.Email = request.Email;
updated.Roles = request.Roles.Where(r => r.IsMemberOf).Select(r => r.Id).ToList();
}
public IActionResult AuthorizationAdmin([FromBody] UpdateUser user)
{
if (_check.CheckUserLogin() == false)
{
return(RedirectToAction("Index", "Login"));
}
if (user.isChecked == "yes")
{
User tempuser = _repositoryUser.GetUser((int)user.Userid);
if (tempuser != null)
{
tempuser.Level = 1;
_logger.WriteLog($"User : {tempuser.UserName} , Updated To Admin Level", Catgory.User);
_repositoryUser.SaveUsers();
}
return(RedirectToAction("Index", "Home"));
}
else
{
User tempuser = _repositoryUser.GetUser((int)user.Userid);
if (tempuser != null)
{
tempuser.Level = 0;
_repositoryUser.SaveUsers();
}
}
return(View("index", "Admin"));
}
public async Task <IActionResult> Update(string username, [FromBody] UpdateUser model)
{
var userToUpdate = await userManager.FindByNameAsync(username);
var user = Request.HttpContext.User;
if (userToUpdate == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, new StatusResponse {
Status = "Error", Message = ""
}));
}
if (user.Identity.Name != userToUpdate.UserName && user.Claims.Where(s => s.Type == typeSchema).Any(s => s.Value == "Admin") == false)
{
return(StatusCode(StatusCodes.Status401Unauthorized, new StatusResponse {
Status = "Error", Message = "Unathorized to update this user!"
}));
}
var mappedResult = mapper.Map <UpdateUser, Account>(model, userToUpdate);
var result = await userManager.UpdateAsync(mappedResult);
if (!result.Succeeded)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new StatusResponse {
Status = "Error", Message = "User update failed! Please check user details and try again."
}));
}
return(Ok(new StatusResponse {
Status = "Success", Message = "User updated successfully!"
}));
}
public IActionResult UpdateProfile([FromBody] UpdateUser user)
{
System.Diagnostics.Debug.WriteLine($"{user.Email} {user.FirstName} {user.SecondName} {user.LastName} {user.Roles}");
var u = _userManager.GetByEmail(user.Email);
if (u != null)
{
if (u.FirstName != user.FirstName)
{
_logger.LogInformation($"User[{u.Email}], Changed FirstName: [{u.FirstName}] -> [{user.FirstName}] |");
u.FirstName = user.FirstName;
}
if (u.SecondName != user.SecondName)
{
_logger.LogInformation($"User[{u.Email}], Changed SecondName: [{u.SecondName}] -> [{user.SecondName}] |");
u.SecondName = user.SecondName;
}
if (u.LastName != user.LastName)
{
_logger.LogInformation($"User[{u.Email}], Changed LastName: [{u.LastName}] -> [{user.LastName}] |");
u.LastName = user.LastName;
}
var rolesBefore = _roleManager.GetAllRolesByUserId(u.Id);
_userManager.RemoveFromRoles(u.Email, rolesBefore.ToList());
var rolesAfter = user.Roles;
_userManager.AddToRoles(u.Email, rolesAfter.ToList());
rolesAfter = _roleManager.GetAllRolesByUserId(u.Id);
_userManager.UpdateUser(u);
return(Ok());
}
return(BadRequest(new { message = "No such user." }));
}
public UserControllerTests()
{
// Initializate data on start
_existingUser = new CreateUser
{
Email = "*****@*****.**",
FirstName = "exist",
LastName = "exist",
Password = "******"
};
_existingUserForDelete = new CreateUser
{
Email = "*****@*****.**",
FirstName = "existForDetele",
LastName = "existForDetele",
Password = "******"
};
_nonExistingUser = new UpdateUser
{
Email = "*****@*****.**",
FirstName = "Non existing user name",
LastName = "Non existing user name",
Password = "******"
};
RegisterUserAsync(_existingUser);
RegisterUserAsync(_existingUserForDelete);
}
public async Task UpdateUserHandlerInvokesUpdateUserWithTheCorrectUser()
{
var options = this.CreateNewContextOptions();
const string userId = "12345";
const string firstName = "changed";
var message = new UpdateUser {
User = new ApplicationUser {
Id = userId,
FirstName = firstName
}
};
using (var context = new AllReadyContext(options)) {
context.Users.Add(new ApplicationUser {
Id = userId,
FirstName = "notChanged"
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new UpdateUserHandler(context);
await sut.Handle(message);
}
using (var context = new AllReadyContext(options)) {
var user = context.Users.FirstOrDefault(u => u.Id == userId);
Assert.NotNull(user);
Assert.Equal(user.FirstName, firstName);
}
}
public async Task <SuccessResponse> UpdateAsync <T>(string id, User <T> user, bool autoName = true, bool destructive = false)
{
Ensure.ArgumentNotNull(user, nameof(user));
var additionalParams = new Dictionary <string, string>();
additionalParams.Add("auto_name", autoName.ToString().ToLowerInvariant());
var updateUser = new UpdateUser <T>
{
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
Name = user.Name,
Profile = user.Profile,
Username = user.Username
};
if (destructive)
{
return(await HttpConnection.PutAsync <SuccessResponse>($"/users/{id}", updateUser, additionalParams));
}
else
{
return(await HttpConnection.PatchAsync <SuccessResponse>($"/users/{id}", updateUser, additionalParams));
}
}
public async Task <Guid> Handle(UpdateUser message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var user = await _userManager.FindByIdAsync(message.Id);
user.FirstName = message.FirstName;
user.LastName = message.LastName;
user.Email = message.Email;
user.PhoneNumber = message.PhoneNumber;
if (message.IsAdministrator)
{
if (user.Roles.Contains(Roles.OrganizationAdministrator) == false)
{
user.Roles.Add(Roles.OrganizationAdministrator);
}
}
else
{
if (user.Roles.Contains(Roles.OrganizationAdministrator))
{
user.Roles.Remove(Roles.OrganizationAdministrator);
}
}
await _userManager.UpdateAsync(user);
//await _session.SaveChangesAsync();
return(Guid.Parse(user.Id));
}
public async Task <UserResponse> Update(UpdateUser request)
{
var requestManager = _mapper.Map <UserAccess>(request);
var user = await _userDataAccess.UpdateAsync(requestManager);
return(_mapper.Map <UserResponse>(user));
}
private void metroGrid1_CellClick(object sender, DataGridViewCellEventArgs e)
{
if (e.ColumnIndex == 0)
{
int Id = (int)metroGrid1.Rows[e.RowIndex].Cells["Id"].Value;
UpdateUser f = new UpdateUser(Id);
f.Show();
}
else if (e.ColumnIndex == 1)
{
int Id = (int)metroGrid1.Rows[e.RowIndex].Cells["Id"].Value;
var result = MetroFramework.MetroMessageBox.Show(this, "آیا مطمئن هستید این آیتم حذف شود؟", "اخطار", MessageBoxButtons.YesNo, MessageBoxIcon.Error);
if (result == DialogResult.Yes)
{
repository.Delete(Id);
UserManagement userManagement = (UserManagement)Application.OpenForms["UserManagement"];
userManagement.LoadGrid();
}
else
{
UserManagement userManagement = (UserManagement)Application.OpenForms["UserManagement"];
userManagement.LoadGrid();
}
}
}
private void BtnUpdateUser_Click(object sender, EventArgs e)
{
UpdateUser updateUser = new UpdateUser();
this.Hide();
updateUser.Show();
}
public async Task <IActionResult> Edit([FromBody] UpdateUser model, string id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Users user = await _usersRepository.GetById(id);
if (user == null)
{
return(NotFound());
}
if (!HttpContext.User.IsInRole(UserRoles.Administrator) && (HttpContext.User.Identity.Name != user.UserName))
{
return(Forbid());
}
IdentityRole role = await _rolesRepository.GetById(model.RoleId);
if (role == null)
{
return(BadRequest(ResponseMessage.RoleNotExists));
}
user = _mapper.Map <UpdateUser, Users>(model, user);
user.DateModified = DateTime.Now;
await _usersRepository.Update(user, model.RoleId);
return(Ok());
}
private async void btnUpdate_Click(object sender, EventArgs e)
{
if (lbxUsers.SelectedValue == null)
{
return;
}
Permission permissions = 0;
for (var i = 0; i < clbPermissions.Items.Count; i++)
{
permissions |= (Permission)Enum.Parse(typeof(Permission), clbPermissions.Items[i].ToString(), true);
}
try
{
var user = await ApiClient.ReadUser((Guid)lbxUsers.SelectedValue);
var updateUser = new UpdateUser(user)
{
FirstName = txtFirstname.Text,
LastName = txtLastname.Text,
};
user = await ApiClient.UpdateUser(user.Id, updateUser);
lbxUsers.SelectedValue = user.Id;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public Response UpdateUser(UpdateUser updateUser)
{
using (Entities entities = new Entities())
{
var DelUser = entities.Users.Where(x => x.userId == updateUser.userId).FirstOrDefault();
if (DelUser != null)
{
DelUser.email = updateUser.Email;
DelUser.phone = updateUser.Phone.ToString();
DelUser.userName = updateUser.UserName;
entities.SaveChanges();
return(new Response()
{
Status = ResponseTypes.ok
});
}
else
{
return(new Response()
{
Status = ResponseTypes.invalid, ErrorMessageText = "User not exits"
});
}
}
}
public bool UpdateUser(UpdateUser updateUser)
{
bool result = false;
try
{
var dbUser = FindUserByUserName(updateUser.Username);
if (dbUser == null)
{
return(result);
}
var user = _mapper.Map(updateUser, dbUser);
_context.SaveChanges();
result = true;
}
catch (System.Exception ex)
{
_logger.LogError(ex.Message);
}
return(result);
}
public void Update_User_Returns_Valid_User()
{
// Arrange
GetUser();
var user = _sut.Users.GetUser(_userEmail);
var originalLastName = user.LastName;
var newLastName = $"Last Name {DateTimeOffset.Now.ToUnixTimeMilliseconds()}";
var updateUser = new UpdateUser
{
FirstName = user.FirstName,
LastName = newLastName
};
// Act
var result = _sut.Users.UpdateUser(_userEmail, updateUser);
// Assert
result.ShouldNotBeNull();
result.ShouldBe(true);
user = _sut.Users.GetUser(_userEmail);
user.Email.ShouldBe(_userEmail);
user.LastName.ShouldBe(newLastName);
// Cleanup
_sut.Users.UpdateUser(_userEmail, new UpdateUser
{
FirstName = user.FirstName,
LastName = originalLastName
});
}
public void Any(UpdateUser request)
{
using (var db = DbFactory.OpenDbConnection())
{
db.Update <UserAuth>(request.User);
}
}
public async Task <IActionResult> UpdateDetails(UpdateUser newDetails)
{
if (!User.Identity.IsAuthenticated)
{
return(LogIn());
}
User user = _userRepo.GetUserList.FirstOrDefault(u => u.UserName == User.Identity.Name);
if (user == null)
{
return(LogIn());
}
IdentityResult result = null;
List <IdentityError> errors = null;
if (!string.IsNullOrEmpty(newDetails.CurrentPassword))
{
result = await _userManager.ChangePasswordAsync(user, newDetails.CurrentPassword, newDetails.Password);
errors = result.Errors.ToList();
}
_userRepo.UpdateUser(user.Id, newDetails);
return(UpdateDetails(errors));
}
public IActionResult UpdateProfile(int id, UpdateUser inp, string bio)
{
List <CurrentUser> ret = HttpContext.Session.GetObjectFromJson <List <CurrentUser> >("curr");
Users showuser = _context.users.Include(u => u.goals).Include(u => u.groups).SingleOrDefault(u => u.id == id);
if (ret[0] == null)
{
return(RedirectToAction(""));
}
else if (ret[0].id == 0 || ret[0].id != id)
{
return(RedirectToAction(""));
}
else
{
if (ModelState.IsValid)
{
Users check = _context.users.SingleOrDefault(x => x.id == id);
check.first_name = inp.first_name;
check.last_name = inp.last_name;
check.privacy = inp.privacy;
check.bio = bio;
_context.SaveChanges();
return(Redirect($"/profile/{id}"));
}
else
{
ViewBag.Profile = showuser;
ViewBag.CurrentUser = ret[0];
return(View("UpdateInfo"));
}
}
}
public bool UpdateUser(string userId, UpdateUser user)
{
var request = BuildRequestAuthorization(PATCH_USER, Method.PATCH);
request.AddParameter("userId", userId, ParameterType.UrlSegment);
request.AddJsonBody(user);
var response = WebClient.Execute(request);
if (response.ResponseStatus == ResponseStatus.Completed && response.StatusCode == System.Net.HttpStatusCode.NoContent)
{
return(true);
}
if (!string.IsNullOrWhiteSpace(response.ErrorMessage))
{
throw new Exception(response.ErrorMessage);
}
if (!string.IsNullOrWhiteSpace(response.StatusDescription) && !string.IsNullOrWhiteSpace(response.Content))
{
throw new Exception($"{response.StatusDescription} || {response.Content}");
}
return(false);
}
public async Task <ActionResult> Update(SettingsPageModel model)
{
var site = await _contextService.CurrentSiteAsync();
var user = await _contextService.CurrentUserAsync();
if (model.User.Id != user.Id || user.IsSuspended)
{
_logger.LogWarning("Unauthorized access to update settings.", new
{
SiteId = site.Id,
UserId = model.User?.Id,
User = User.Identity.Name
});
return(Unauthorized());
}
var command = new UpdateUser
{
Id = user.Id,
DisplayName = model.User.DisplayName,
SiteId = site.Id,
UserId = user.Id
};
await _userService.UpdateAsync(command);
return(Ok());
}
public string UpdateUser([FromBody] UpdateUser user)
{
try
{
if (_context.Users.Any(x => x.UserId == user.UserId))
{
var UserDetails = _context.Users.Find(user.UserId);
UserDetails.Title = user.Title;
UserDetails.FirstName = user.FirstName;
UserDetails.LastName = user.LastName;
UserDetails.Email = user.Email;
UserDetails.Phone = user.Phone;
UserDetails.IsAdmin = user.IsAdmin;
UserDetails.Address = user.Address;
_context.SaveChanges();
return("Success");
}
else
{
return("Error: Group not found!");
}
}
catch (Exception ex)
{
return("Error:" + ex.Message);
}
}
public void Handle(UpdateUser update)
{
if (update.User.Id == _protoService.Options.MyId)
{
CreateToastCollection(update.User);
}
}
public async Task updateuser_command_should_modify_user_with_given_data()
{
var id = new AggregateId();
var email = "*****@*****.**";
var fullname = "fullname";
var updatedFullname = "updatedfullname";
var password = "******";
var pic = "test.nl/image";
var role = Role.User;
var securityStamp = new Guid().ToString();
// Add user
var user = new User(id, email, fullname, pic, password, role, securityStamp, 0, DateTime.MinValue, DateTime.UtcNow,
new string[] { });
await _mongoDbFixture.InsertAsync(user.AsDocument());
var command = new UpdateUser(id, updatedFullname, pic, null);
_commandHandler
.Awaiting(c => c.HandleAsync(command))
.Should().NotThrow();
var updatedUser = await _mongoDbFixture.GetAsync(command.UserId);
updatedUser.Should().NotBeNull();
updatedUser.Id.Should().Be(command.UserId);
updatedUser.Fullname.Should().Be(command.Fullname);
updatedUser.Pic.Should().Be(command.Pic);
}
public async Task <IActionResult> UpdateUser(string id, UpdateUser model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
if (id == null)
{
return(View("Error"));
}
var currentUser = await _userManager.FindByIdAsync(id);
if (currentUser == null)
{
return(View("Error"));
}
else
{
currentUser.UserName = model.UserName;
currentUser.Email = model.Email;
currentUser.PhoneNumber = model.PhoneNumber;
currentUser.NameOnCard = model.NameOnCard;
currentUser.CreditCard = model.CreditCard;
currentUser.CardConfirm = model.CardConfirm;
currentUser.Month = model.Month;
currentUser.Year = model.Year;
currentUser.Line1 = model.Line1;
currentUser.Line2 = model.Line2;
currentUser.City = model.City;
currentUser.State = model.State;
currentUser.Zip = model.Zip;
currentUser.Country = model.Country;
var serviceCollection = new ServiceCollection();
serviceCollection.AddDataProtection();
var services = serviceCollection.BuildServiceProvider();
var instance = ActivatorUtilities.CreateInstance <Encryptor>(services);
var content = instance.Encrypt(currentUser.CreditCard);
var contentConfirm = instance.Encrypt(currentUser.CardConfirm);
currentUser.CreditCard = content;
currentUser.CardConfirm = contentConfirm;
IdentityResult result = await _userManager.UpdateAsync(currentUser);
if (result.Succeeded)
{
return(RedirectToLocal(returnUrl));
}
else
{
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
}
return(View(model));
}
public IHttpActionResult Update(UpdateUser user)
{
if (user == null)
{
return(BadRequest());
}
// OldPassword needs to be correct
var authenticatedUser = _userRepository.Authenticate(user.UserName, user.PasswordOld);
if (authenticatedUser == null)
{
return(BadRequest("Old password not okay"));
}
if (user.PasswordOld == user.Password)
{
return(BadRequest("New password must be different from old one"));
}
if (!CheckPasswordAndVerification(user, out var error))
{
return(error);
}
var result = _userRepository.Update(authenticatedUser.Id, user.Password);
return(result ? (IHttpActionResult)Ok() : BadRequest());
}
/// <summary>
/// Posts the specified request.
/// </summary>
/// <param name="request">The request.</param>
public void Post(UpdateUser request)
{
// We need to parse this manually because we told service stack not to with IRequiresRequestStream
// https://code.google.com/p/servicestack/source/browse/trunk/Common/ServiceStack.Text/ServiceStack.Text/Controller/PathInfo.cs
var id = GetPathValue(1);
AssertCanUpdateUser(_authContext, _userManager, id, false);
var dtoUser = request;
var user = _userManager.GetUserById(id);
if (string.Equals(user.Name, dtoUser.Name, StringComparison.Ordinal))
{
_userManager.UpdateUser(user);
}
else
{
var task = _userManager.RenameUser(user, dtoUser.Name);
Task.WaitAll(task);
}
_userManager.UpdateConfiguration(dtoUser.Id, dtoUser.Configuration);
}
public ActionResult Update(string userSlug, UpdateUser command)
{
command.User.Id = EventSite.Domain.Model.User.IdFrom(userSlug);
return Execute(command)
.OnSuccess(x => View("Update", command))
.OnFailure(x => View("Update", command));
}
public Response Patch(UpdateUser request)
{
request.Username = request.Username.Trim();
request.Email = request.Email.Trim();
Db.Update(request.ConvertTo<User>());
Request.RemoveFromCache(Cache, request.Id.ToString());
return new Response(true);
}
public void Put(UpdateUser request)
{
_userRepo.Update(new User
{
FullName = request.FullName,
UserName = request.UserName,
Id = request.Id,
RoleId = request.RoleId
});
}
public ActionResult Update(string userSlug)
{
var user = LoadUserFromSlug(userSlug);
if (user == null) {
return NotFound();
}
var userData = new UpdateUser();
userData.User = user;
userData.InAdminRole = user.InRole(Roles.Admin);
userData.InSponsorManagerRole = user.InRole(Roles.ManageSponsors);
return View(userData);
}
public async Task HandleAsync_WithNonInternalAccess_ThrowsSecurityException(AuthorizationBuilder.UserType userType)
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateFromUserType(userType);
UserManager<ApplicationUser> userManager = A.Fake<UserManager<ApplicationUser>>();
var handler = new UpdateUserHandler(authorization, userManager);
var request = new UpdateUser(Guid.NewGuid().ToString(), "TestFirstName", "TestLastName");
// Act
Func<Task> action = async () => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync<SecurityException>(action);
}
public async Task HandleAsync_WithUnknownUserId_ThrowsArgumentException()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
UserManager<ApplicationUser> userManager = A.Fake<UserManager<ApplicationUser>>();
A.CallTo(() => userManager.FindByIdAsync("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1")).Returns((ApplicationUser)null);
var handler = new UpdateUserHandler(authorization, userManager);
var request = new UpdateUser("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1", "TestFirstName", "TestLastName");
// Act
Func<Task> action = async () => await handler.HandleAsync(request);
// Assert
await Assert.ThrowsAsync<ArgumentException>(action);
}
public ActionResult UpdateUserType(UpdateUser input)
{
var result = new {Succss = true, Message = "Updated"};
return Json(result);
}
public User Update(UpdateUser request)
{
var httpRequest = RequestContext.Get<IHttpRequest>();
var userSession = httpRequest.GetSession();
if(!( userSession.HasRole(RoleNames.Admin)
|| userSession.HasPermission("User.update")
))
throw HttpError.Unauthorized("Update no allowed");
var authRepo = httpRequest.TryResolve<IUserAuthRepository>();
if(authRepo==null)
throw HttpError.NotFound("AuthRepository NO found");
var user= authRepo.GetUserAuth(request.Id.ToString());
if (!(request.Id== int.Parse(userSession.UserAuthId) ||
userSession.HasRole(RoleNames.Admin)) )
throw HttpError.Unauthorized("Update no allowed (no admin)");
if(user == default(UserAuth))
throw HttpError.NotFound(
string.Format("User Id:'{0}' NO found",request.Id));
var newUser= new UserAuth
{
Id= request.Id,
FirstName= request.FirstName,
LastName= request.LastName,
Email= request.Email,
UserName= request.UserName,
DisplayName= request.FirstName+" "+request.LastName,
ModifiedDate= DateTime.Now,
};
newUser.Set<UserMeta>( new UserMeta{
Info= request.Info,
IsActive=request.IsActive,
ExpiresAt= request.ExpiresAt
});
if(request.Password.IsNullOrEmpty())
{
AuthRepoProxy.Execute(db=>{
db.UpdateOnly(
newUser,
ev=>ev.Where(q=>q.Id==request.Id).
Update(f=> new {
f.UserName, f.FirstName, f.LastName, f.Email, f.Meta,
f.DisplayName,
f.ModifiedDate
}));
});
}
else
{
user = authRepo.UpdateUserAuth(user, newUser,request.Password);
}
User u = new User();
u.PopulateWith(newUser);
return u;
}
public async Task HandleAsync_HappyPath_UpdatedUserInformation()
{
// Arrange
IWeeeAuthorization authorization = AuthorizationBuilder.CreateUserWithAllRights();
ApplicationUser user = new ApplicationUser();
UserManager<ApplicationUser> userManager = A.Fake<UserManager<ApplicationUser>>();
A.CallTo(() => userManager.FindByIdAsync("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1")).Returns(user);
A.CallTo(() => userManager.UpdateAsync(user)).Returns(IdentityResult.Success);
var handler = new UpdateUserHandler(authorization, userManager);
var request = new UpdateUser("722F0857-EE0A-4460-AA7B-0E8EF5B5C8A1", "Test", "Test");
// Act
var result = await handler.HandleAsync(request);
// Assert
Assert.Equal(user.FirstName, "Test");
Assert.Equal(user.Surname, "Test");
A.CallTo(() => userManager.UpdateAsync(user)).MustHaveHappened();
}
