public async Task <ActionResult <UpdateUserViewModel> > Update(UpdateUserInputModel model) { var userId = this.userManger.GetUserId(this.User); var obj = await this.usersService.UpdateUserOrderInfoAsync <UpdateUserViewModel>(userId, model); return(obj); }
public void Update(UpdateUserInputModel inputModel) { var user = _dbContext.Users.SingleOrDefault(u => u.Id == inputModel.Id); user.Update(inputModel.FullName, inputModel.Email, inputModel.Active); _dbContext.SaveChanges(); }
public async Task <IActionResult> Update(UpdateUserInputModel input) { var request = new HttpRequestMessage(HttpMethod.Put, UsersRoot); List <UpdateResponse> result; try { result = await _httpSender.SendPutAsync <List <UpdateResponse>, UpdateUserInputModel>(input, UsersRoot); } catch (Exception) { return(StatusCode(500)); } foreach (var identityResult in result) { if (!identityResult.Succeeded) { return(BadRequest(result)); } } return(Ok(result)); }
public async Task <IdentityResult> UpdateUser([FromBody] UpdateUserInputModel userInputModel) { var user = await this._userManager.FindByIdAsync(userInputModel.Id); if (user is null) { return(null); } user.UserName ??= userInputModel.Username; user.Email ??= userInputModel.Email; user.EmailConfirmed = !(userInputModel.Email is null) ? false : user.EmailConfirmed; user.PhoneNumber ??= userInputModel.PhoneNumber; user.PhoneNumberConfirmed = !(userInputModel.PhoneNumber is null) ? false : user.PhoneNumberConfirmed; if (userInputModel.IsDeleted) { user.DeletedAt = System.DateTime.UtcNow; } else { user.DeletedAt = null; } if (!(userInputModel.Password is null)) { var resetToken = await this._userManager.GeneratePasswordResetTokenAsync(user); await this._userManager.ResetPasswordAsync(user, resetToken, userInputModel.Password); } return(await this._userManager.UpdateAsync(user)); }
public async Task <IActionResult> Put([FromBody] UpdateUserInputModel inputModel, int id) { //_userService.Update(id, inputmodel); var command = new UpdateUserCommand(id, inputModel.Email); await _mediator.Send(command); return(NoContent()); }
public Response <AccountUpdateOutputModel> UpdateAccount(UpdateUserInputModel updateUserInput) { var response = this._sinukaWebAccountsEndpoints.UpdateUser(updateUserInput); return(new Response <AccountUpdateOutputModel>(new AccountUpdateOutputModel() { IsUpdated = response.Succeeded, })); }
public async Task <IdentityResult> Update(UpdateUserInputModel model, string username) { var currentUser = await this.userManager.FindByNameAsync(username); currentUser.UserName = model.UserName; currentUser.Email = model.Email; currentUser.PhoneNumber = model.PhoneNumber; var result = await this.userManager.UpdateAsync(currentUser); return(result); }
public async Task <IActionResult> Put(int id, [FromBody] UpdateUserInputModel updateUserInputModel) { var command = new UpdateUserCommand(id, updateUserInputModel.Name, updateUserInputModel.Email); var result = await _mediator.Send(command); if (result == null) { return(NotFound()); } return(Ok()); }
public async Task ChangeUserInfo_ShouldThrow() { this.Initialize(); this.SeedUser(); var inputModel = new UpdateUserInputModel() { FullName = TestFullName, PhoneNumber = TestPhone }; await Assert.ThrowsAsync <UserNotFoundException>(() => this.service.UpdateUserOrderInfoAsync <UpdateUserViewModel>(TestId, inputModel)); }
public async Task ChangeUserInfo_ShouldChangeAndReturnViewModel() { this.Initialize(); this.SeedUser(); var inputModel = new UpdateUserInputModel() { FullName = TestFullName, PhoneNumber = TestPhone }; var viewModel = await this.service.UpdateUserOrderInfoAsync <UpdateUserViewModel>(UserId, inputModel); Assert.Equal(TestFullName, viewModel.FullName); Assert.Equal(TestPhone, viewModel.PhoneNumber); }
public async Task <IActionResult> Update(UpdateUserInputModel input) { IEnumerable <IdentityResult> result = new List <IdentityResult>(); result = await _userService.Update(input.CurrentUserName, input.NewUserName, input.CurrentPassword, input.CurrentPassword, input.CurrentEmail, input.NewEmail); foreach (var identityResult in result) { if (!identityResult.Succeeded) { return(BadRequest(result)); } } return(Ok(result)); }
public void Validate_Fails_Mismatched_Passwords() { // Arrange var model = new UpdateUserInputModel { UserId = 1, Email = "*****@*****.**", Password = "******", ConfirmPassword = "******" }; var validationDictionary = new ValidationDictionary(); // Act var result = model.ValidateRequest(validationDictionary); // Assert Assert.IsFalse(result); }
public void Validate_Successful_With_Valid_Information() { // Arrange var model = new UpdateUserInputModel { UserId = 1, Email = "*****@*****.**", Password = "******", ConfirmPassword = "******" }; var validationDictionary = new ValidationDictionary(); // Act var result = model.ValidateRequest(validationDictionary); // Assert Assert.IsTrue(result); }
/// <summary> /// Executes the command /// </summary> /// <returns>updated user</returns> public async Task <User> Execute(int id, UpdateUserInputModel model) { // Check access rights: Admin await accessRightChecker.CheckUserIsAdmin(); // pretreatment of model model.CheckAndPrepare(); // specific validation model.Email = model.Email.ToLower(); // making lowercase if (!EmailValidationUtility.CheckIsValidEmail(model.Email)) { throw new BusinessException("Email specified not correctly"); } if (await userRepository.AnyAsync(a => a.Id != id && a.Email == model.Email)) { throw new BusinessException("User with specified email already exists"); } // gets the user User user = await userRepository.GetById(id).FirstOrDefaultAsync(); if (user is null) { throw new BusinessException("User does not exist"); } // updates the user user.Email = model.Email; user.Name = model.Name; user.AuthenticationTokenId = Guid.NewGuid(); // generating new token id // saves made changes await changesSaver.SaveChangesAsync(); return(user); }
public async Task <IActionResult> UpdateAsync([FromForm] UpdateUserInputModel model) { var service = Ioc.Get <IUserService>(); var user = await service.GetUserById(model.Id); if (user == null) { return(Ok(new StandardResult().Fail(StandardCode.ArgumentError, "用户不存在"))); } user.RealName = model.RealName; user.IdCard = model.IdCard; user.Email = model.Email; user.Birthday = model.Birthday; user.Mobile = model.Mobile; user.Gender = model.Gender; user.Enabled = model.Enabled; user.ModifiedBy = CurrentUserId; user.ModifiedTime = DateTime.Now; await service.UpdateAsync(user); return(Ok(new StandardResult().Succeed("更新成功"))); }
public async Task <IdentityResult> UpdateUser(UpdateUserInputModel user, string username) { var result = await this.userService.Update(user, username); return(result); }
public IdentityResult UpdateUser(UpdateUserInputModel userInputModel) { return(this._sinukaWebAccountsEndpoint.UpdateUser(userInputModel)); }
public async Task <ActionResult> Update(string userId, UpdateUserInputModel input) { await this.usersService.UpdateAsync(userId, input.Username, input.Password); return(this.Ok()); }
public async Task Update([FromBody] UpdateUserInputModel model, int id) { model.Id = id; await _unitOfWork.SaveChangesAsync(_userWriterService.Save(model)); }
public BaseResponseModel Update(UpdateUserInputModel inputModel) { var vm = new BaseResponseModel(); // Validate request var validationState = new ValidationDictionary(); inputModel.ValidateRequest(validationState); // Get existing user var user = UserService.GetUserById(inputModel.UserId); if (user == null) { throw new HttpException(404, "User not found."); } // Do not allow editing of users other than yourself if you // don't have permissions if (!CurrentUser.HasPermission(Permission.EditUsers) && user.Id != CurrentUser.Id) { throw new HttpException(401, "You do not have permissions to complete this action."); } // Copy properties bool emailChanged = user.Email != inputModel.Email; user.Email = inputModel.Email; string newPass = String.IsNullOrWhiteSpace(inputModel.Password) ? null : inputModel.Password; // Additional properties for admin users if (CurrentUser.HasPermission(Permission.EditUsers)) { if (inputModel.Role.HasValue) { user.Role = inputModel.Role.Value; } } if (UserService.ValidateUser(user, validationState)) { UserService.UpdateUser(user, newPass); if (emailChanged) { ReAuthorizeUser(inputModel.Email); } LogService.CreateLog(new Log { Category = LogCategory.Application, IpAddress = GetClientIp(ControllerContext.Request), Level = LogLevel.Info, Message = "User " + inputModel.Email + " (ID #" + user.Id + ") was updated.", User = CurrentUser }); vm.Success = true; } vm.Errors = validationState.Errors; return(vm); }
public async Task <TViewModel> UpdateUserOrderInfoAsync <TViewModel>(string id, UpdateUserInputModel model) { var user = await this.context .Users .SingleOrDefaultAsync(x => x.Id == id); if (user == null) { throw new UserNotFoundException(string.Format(ExceptionMessages.UserLookupFailed, id)); } if (user.FullName != model.FullName || user.PhoneNumber != model.PhoneNumber) { user.FullName = model.FullName; user.PhoneNumber = model.PhoneNumber; await this.context.SaveChangesAsync(); } var viewModel = this.mapper.Map <TViewModel>(user); return(viewModel); }
public IdentityResult UpdateUser(UpdateUserInputModel userInputModel) { return(this._sinukaWebAccountsEndpoint.UpdateUser(userInputModel, LoginAndFetchToken())); }
public async Task Update(int id, [FromBody] UpdateUserInputModel model) => await updateUserCommand.Execute(id, model);