public async Task <UserVm> UpdateUser(int userId, UpdateUserVm model) { var updateUserDto = new UpdateUserDto { FirstName = model.FirstName, LastName = model.LastName, Id = userId }; var file = model.Image; if (file != null) { var extension = "." + file.FileName.Split(".").LastOrDefault(); if (string.IsNullOrEmpty(extension)) { extension = string.Empty; } var imagesDirectory = Path.Combine(_appEnvironment.ContentRootPath, _commonSettings.UserImagesFolder); if (!Directory.Exists(imagesDirectory)) { Directory.CreateDirectory(imagesDirectory); } updateUserDto.ImageLocalUrl = Path.Combine(imagesDirectory, $"{userId}{extension}"); await using var fileStream = new FileStream(updateUserDto.ImageLocalUrl, FileMode.Create); await file.CopyToAsync(fileStream); updateUserDto.ImageCode = StringExtensions.GenerateUniqueRandomToken(); updateUserDto.ImageThumbnailUrl = $"{_commonSettings.ApplicationUrl}/api/user/image/{updateUserDto.ImageCode}"; } await _userRepository.UpdateUser(updateUserDto); return(await this.GetUserById(userId)); }
public async Task <IActionResult> Update(Guid userID, UpdateUserDto updateUserInfo) { var user = new User { ID = userID }; #region [Authorization] var result = await this.AuthorizationService.AuthorizeAsync ( this.User, user, nameof(KindlyPolicies.AllowIfOwner) ); if (result.Succeeded == false) { return(this.Unauthorized()); } #endregion this.Mapper.Map(updateUserInfo, user); await this.Repository.Update(user); return(this.Ok()); }
public async Task <int> UpdateAsync(UpdateUserDto updateUserDto) { const string query = @" UPDATE [Users] SET [UserName] = @UserName ,[NormalizedUserName] = @NormalizedUserName ,[Email] = @Email ,[NormalizedEmail] = @NormalizedEmail ,[EmailConfirmed] = @EmailConfirmed ,[PasswordHash] = @PasswordHash ,[SecurityStamp] = @SecurityStamp ,[ConcurrencyStamp] = @ConcurrencyStamp ,[PhoneNumber] = @PhoneNumber ,[PhoneNumberConfirmed] = @PhoneNumberConfirmed ,[TwoFactorEnabled] = @TwoFactorEnabled ,[LockoutEnd] = @LockoutEnd ,[LockoutEnabled] = @LockoutEnabled ,[AccessFailedCount] = @AccessFailedCount WHERE [Id] = @Id; "; using (var connection = _dbConnectionFactory.GetDbConnection()) { var updatedRowsNum = await connection.ExecuteAsync(query, updateUserDto); return(updatedRowsNum); } }
public async Task <IActionResult> UpdateUserAsync(Guid userId, [FromBody] UpdateUserDto user, [FromHeader(Name = "Accept")] string mediaType) { if (!MediaTypeHeaderValue.TryParse(mediaType, out MediaTypeHeaderValue parsedMediaType)) { return(BadRequest()); } var userDto = await _userService.UpdateUserAsync(userId, user); if (userDto == null) { return(NotFound()); } var includeLinks = parsedMediaType.SubTypeWithoutSuffix.EndsWith("hateoas", StringComparison.InvariantCultureIgnoreCase); if (includeLinks) { IEnumerable <LinkDto> links = new List <LinkDto>(); links = CreateUserLinks(userId); var userWithLinks = _mapper.Map <ResponseUserLinksDto>(userDto); userWithLinks.Links = links; return(Ok(userWithLinks)); } return(Ok(userDto)); }
public async Task <(bool, string)> UpdateAsync([FromForm] UpdateUserDto updateUserDto) { logger.LogInformation("Updated Successfulluy", updateUserDto); return(await userService.UpdateAsync(updateUserDto)); }
public async Task <IDataResult <User> > Update(UpdateUserDto userDto) { BusinessRules.Run(CheckUserExists(userDto.Id)); User userEntity = _userDal.Get(c => c.Id == userDto.Id); if (!string.IsNullOrEmpty(userDto.FirstName)) { CheckEmailNotExists(userDto.Email); userEntity.Email = userDto.Email; } if (!string.IsNullOrEmpty(userDto.Password)) { userDto.Password = BCrypt.Net.BCrypt.HashPassword(userDto.Password); } if (!string.IsNullOrEmpty(userDto.FirstName)) { userEntity.FirstName = userDto.FirstName; } if (!string.IsNullOrEmpty(userDto.LastName)) { userEntity.LastName = userDto.LastName; } var user = await _userDal.Update(userEntity); return(new SuccessDataResult <User>(user)); }
public async Task <ServiceResponse <GetUserDto> > UpdateUser(int id, UpdateUserDto updateUserDto) { ServiceResponse <GetUserDto> response = new ServiceResponse <GetUserDto> (); try { User user = await _context.Users.FirstOrDefaultAsync(u => u.Id == id); if (user == null) { response.Success = false; response.Message = $"User with id {id} not found!"; return(response); } var updateUser = _mapper.Map <User> (updateUserDto); _context.Entry(updateUser).State = EntityState.Modified; await _context.SaveChangesAsync(); response.Data = _mapper.Map <GetUserDto> (updateUser); return(response); } catch (System.Exception ex) { response.Success = false; response.Message = ex.Message; } return(response); }
public void Execute(int id, UpdateUserDto dto) { dto.Id = id; var user = _context.Users.Find(id); if (user == null) { throw new EntityNotFoundException(id, typeof(User)); } _validator.ValidateAndThrow(dto); /*_mapper.Map(dto, user);*/ user.FirstName = dto.FirstName; user.LastName = dto.LastName; user.Password = dto.Password; user.Email = dto.Email; user.UserUseCases = dto.UserUseCases.Select(u => new UserUseCase { UseCaseId = u.UseCaseId }).ToList(); _context.SaveChanges(); }
public async Task <ActionResult <GetUserDto> > UpdateAsync( [FromBody][Required] UpdateUserDto updateUserDto, CancellationToken cancellationToken) { var currentUser = await _userManager.GetUserAsync(HttpContext.User) .ConfigureAwait(false); if (currentUser is null) { return(NotFound()); } if (updateUserDto.PasswordChange.OldPassword != string.Empty) { var result = await _userManager.ChangePasswordAsync( currentUser, updateUserDto.PasswordChange.OldPassword, updateUserDto.PasswordChange.NewPassword) .ConfigureAwait(false); if (!result.Succeeded) { return(BadRequest("Old password is incorrect.")); } } var updatedUser = await _user.DoUpdateAsync(currentUser, updateUserDto, cancellationToken) .ConfigureAwait(false); var userDto = CreateUserDto(updatedUser !); return(Ok(userDto)); }
public async Task <ServiceResponse <GetUserDto> > UpdateUser(UpdateUserDto updateCharacter) { ServiceResponse <GetUserDto> serviceResponse = new ServiceResponse <GetUserDto>(); try { User user = _context.Users.FirstOrDefault(u => u.Id == updateCharacter.Id); user.Username = updateCharacter.Username; user.EmailAddress = updateCharacter.EmailAddress; user.Role = updateCharacter.Role; if (user.Password != updateCharacter.Password) { user.Password = updateCharacter.Password; user.Salt = updateCharacter.Salt; user.LastPasswordChange = updateCharacter.LastPasswordChange; user.EnforcePasswordChange = false; } serviceResponse.Data = _mapper.Map <GetUserDto>(user); _context.SaveChanges(); } catch (Exception ex) { serviceResponse.Success = false; serviceResponse.Message = (ex.InnerException != null) ? ex.InnerException.Message : ex.Message; } return(serviceResponse); }
public async Task <IActionResult> UpdateUserShift([FromBody] UpdateUserDto updatedUser) { var newUser = new User { UserId = updatedUser.UserId, AccountId = updatedUser.AccountId, FirstName = updatedUser.FirstName, LastName = updatedUser.LastName, Gender = updatedUser.Gender, DepartmentId = updatedUser.DepartmentId, PositionId = updatedUser.PositionId }; await _userShiftRepo.DeleteAsync(d => d.UserId == updatedUser.UserId); await _userRepo.UpdateAsync(newUser); if (updatedUser.UserShifts.Count > 0) { foreach (var userShift in updatedUser.UserShifts) { var newUserShift = new UserShift { ShiftId = userShift.ShiftId, UserId = userShift.UserId, Day = userShift.Day }; await _userShiftRepo.CreateAsync(newUserShift); } } return(Ok(await GetUserList())); }
public async Task <bool> Update(UpdateUserDto entity) { var item = await _context.Users.FindAsync(entity.ID); item.EmployeeID = entity.EmployeeID; item.Username = entity.Username; item.Email = entity.Email; item.ModifyTime = DateTime.Now; if (!entity.Password.IsNullOrEmpty()) { byte[] passwordHash, passwordSalt; CreatePasswordHash(entity.Password, out passwordHash, out passwordSalt); item.PasswordHash = passwordHash; item.PasswordSalt = passwordSalt; } item.ModifyTime = DateTime.Now; try { _context.Users.Update(item); await _context.SaveChangesAsync(); return(true); } catch (Exception) { return(false); } }
public async Task <IActionResult> Update(UpdateUserDto dto) { try { await _service.UpdateAsync(dto); Logger.LogDebug("Successfully updated user with id '{0}'.", dto.Id); return(Ok()); } catch (NotFoundException e) { Logger.LogDebug("Could not update user as no user could be found with id '{0}'.", dto.Id); return(NotFound(e.Message)); } catch (ValidationException e) { Logger.LogDebug("A validation occured while updating the user: {0}", e.Message); return(BadRequest(e.Message)); } catch (Exception e) { Logger.LogError(e, "An error occured while updating the user."); return(InternalServerError(e.Message)); } }
public void Update_existing_user() { NewUserDto newUserDto = new NewUserDto { Name = "Martin", Surname = "Fowler", Username = "******", Password = "******", Email = "*****@*****.**", IsRoot = false }; UpdateUserDto updatedUserDto = new UpdateUserDto { Name = "John", Surname = "Smith", Username = "******", Password = "******", Email = "*****@*****.**", IsRoot = true }; NewUserIdDto newUserIdDto = _managementController.CreateUser(newUserDto); _managementController.UpdateUser(newUserIdDto.Id, updatedUserDto); UserInfoDto userInfoDto = _managementController.GetUser(newUserIdDto.Id); Assert.AreEqual(updatedUserDto.Name, userInfoDto.Name); Assert.AreEqual(updatedUserDto.Surname, userInfoDto.Surname); Assert.AreEqual(updatedUserDto.Email, userInfoDto.Email); Assert.AreEqual(updatedUserDto.Username, userInfoDto.Username); Assert.AreEqual(updatedUserDto.IsRoot, userInfoDto.IsRoot); }
public IActionResult UpdateProfile(UpdateUserDto dto) { if (!ModelState.IsValid) { TempData["error"] = "Check your input."; return(RedirectToAction("MyProfile", new { dto.Id })); } try { updateUser.Execute(dto); TempData["success"] = "You successfully updated your profile."; } catch (EntityCannotBeNullException e) { TempData["error"] = e.Message; } catch (EntityAlreadyExistsException e) { TempData["error"] = e.Message; } catch (EntityMustHaveConfirmedPassword e) { TempData["error"] = e.Message; } catch (Exception e) { TempData["error"] = e.Message; } return(RedirectToAction("MyProfile", "Account", new { dto.Id })); }
public async Task <IActionResult> UpdateUserAsync(UpdateUserDto inputModel) { var user = await userManager.GetUserAsync(User); if (!ModelState.IsValid || !await userManager.CheckPasswordAsync(user, inputModel.CurrentPassword) || inputModel.Password != inputModel.ConfirmPassword) { return(StatusCode(StatusCodes.Status406NotAcceptable)); } var userWithSameUsername = await userManager.FindByNameAsync(inputModel.Username); var userWithSameEmail = await userManager.FindByEmailAsync(inputModel.Email); if ((userWithSameUsername != null && userWithSameUsername.Id != user.Id) || (userWithSameEmail != null && userWithSameEmail.Id != user.Id)) { return(StatusCode(StatusCodes.Status409Conflict)); } await userManager.SetUserNameAsync(user, inputModel.Username); user.Email = inputModel.Email; await userManager.UpdateAsync(user); if (inputModel.Password.Length >= 6) { await userManager.RemovePasswordAsync(user); await userManager.AddPasswordAsync(user, inputModel.Password); } return(StatusCode(StatusCodes.Status201Created)); }
public async Task <IActionResult> UpdateUser(UpdateUserDto user) { var result = await accountService.UpdateUser(AuthenticatedUserEmail, user); switch (result) { case UserModificationResult.NothingToUpdate: case UserModificationResult.SuccessNoConfirmationRequired: return(Ok(new UpdateUserResultDto { IsConfirmationRequired = false })); case UserModificationResult.SuccessConfirmationRequired: return(Ok(new UpdateUserResultDto { IsConfirmationRequired = true })); case UserModificationResult.DuplicateValues: return(BadRequest <UpdateUserDto>(u => u.Email, LocalizedResources.UserDuplicateValuesError)); case UserModificationResult.IncorrectPassword: return(BadRequest <UpdateUserDto>(u => u.OldPassword, LocalizedResources.UserIncorrectPasswordError)); default: throw new InvalidOperationException(nameof(UserModificationResult)); } }
public async Task <IActionResult> Profil(UpdateUserDto model) { if (ModelState.IsValid) { var user = await _userManager.FindByNameAsync(User.Identity.Name); user.Ad = model.Ad; user.Soyad = model.Soyad; user.FirmaAdi = model.FirmaAdi; var result = await _userManager.UpdateAsync(user); if (result.Succeeded) { await _userManager.UpdateSecurityStampAsync(user); await _signInManager.SignOutAsync(); await _signInManager.SignInAsync(user, true); ViewBag.success = "true"; } else { foreach (var item in result.Errors) { ModelState.AddModelError("", item.Description); } } } return(View(model)); }
public async Task UpdateUser(UpdateUserDto input) { var user = await _userRepository.GetByIdAsync(input.Id); if (input.Username != null) { user.Username = input.Username; } if (input.EmailAddress != null) { user.EmailAddress = input.EmailAddress; } if (input.Bio != null) { user.Bio = input.Bio; } if (input.Username != null) { user.Username = input.Username; } user.Gender = input.Gender; if (input.ProfileImage != null) { var imgPath = await _blobService.InsertFile(input.ProfileImage); user.ProfileImagePath = imgPath; } await _userRepository.UpdateAsync(user); }
public async Task <IActionResult> Update(long id, [FromBody] UpdateUserDto model) { if (!User.GetSubjectId().Equals(id.ToString(), StringComparison.InvariantCultureIgnoreCase)) { return(Forbid()); } if (model == null) { return(BadRequest()); } try { var result = await _accountService.UpdateUserAsync(User, model.MapToUserUpdateModel()); if (result.Succeeded) { return(NoContent()); } return(BadRequest(result.Errors)); } catch (UserNotFoundException) { return(Forbid()); } }
public void Update_StateUnderTest_ExpectedBehavior() { var service = this.CreateService(); service.ObjectMapper = LocalIocManager.Resolve <Abp.ObjectMapping.IObjectMapper>(); service.AbpSession = Resolve <IAbpSession>(); LoginAsTenant("Default", "85261586394"); service.UnitOfWorkManager = Resolve <IUnitOfWorkManager>(); service.UnitOfWorkManager.Begin(); // Arrange UpdateUserDto input1 = new UpdateUserDto { Id = 3, UserName = "******", FirstName_ChT = "abc", FirstName_Eng = "abcd", FullName = "abcdef", HKID = "A1234567", Surname = "testing", Name = "testing", LangPreference = "zht", LastName_ChT = "abcd", LastName_Eng = "abcde", }; // Act var result1 = service.Update( input1); // Assert Assert.True(result1.Status == TaskStatus.RanToCompletion && result1.Result != null); //exception SetNormalizedNname null object }
public IActionResult Update([FromBody] UpdateUserDto userDto) { if (_httpContextAccessor.GetCurrentUserId() != userDto.AuthorId) { return(Unauthorized(new ErrorResponseDto { InternalErrorMessage = "Specified userId does not match the authenticated userId.", DisplayErrorMessage = "You are not authorized to update user profile.", })); } var author = _authorService.UpdateProfile(userDto.AuthorId, userDto.Username, userDto.Email, userDto.FirstName, userDto.MiddleName, userDto.LastName); if (author == null) { var errorMessage = "Failed to update user."; return(BadRequest(new ErrorResponseDto { InternalErrorMessage = errorMessage, DisplayErrorMessage = errorMessage, })); } return(Ok(_mapper.Map <UpdateUserResponseDto>(author))); }
public IActionResult Patch(string id, [FromBody] UpdateUserDto model) { if (model == null) { return(BadRequest("No data")); } if (string.IsNullOrEmpty(model.FirstName)) { return(BadRequest("No first name")); } if (string.IsNullOrEmpty(model.LastName)) { return(BadRequest("No last name")); } if (string.IsNullOrEmpty(model.UserName)) { return(BadRequest("No user name")); } var user = new Users { FirstName = _encryptor.Encrypt(model.FirstName), LastName = _encryptor.Encrypt(model.LastName), Role = model.Role, UserName = model.UserName, }; var entity = _crud.UpdateItem(id, user); entity.Password = null; entity.FirstName = _encryptor.Decrypt(entity.FirstName); entity.LastName = _encryptor.Decrypt(entity.LastName); return(Ok(new { user = entity })); }
public async Task <IActionResult> UpdateUser([FromBody] UpdateUserDto updateUser, [FromRoute] Guid id) { if (!ModelState.IsValid) { return(BadRequest()); } var userId = User.Claims.FirstOrDefault(p => p.Type == ClaimTypes.NameIdentifier)?.Value; if (id.ToString() != userId) { return(BadRequest()); } var isUser = _userManager.Users.Any(u => u.Id == id.ToString()); if (!isUser) { return(NotFound()); } var updatedUser = await _userService.UpdateUserAsync(id, updateUser).ConfigureAwait(false); var saved = await _userService.SaveAsync().ConfigureAwait(false); if (!saved) { return(BadRequest()); } var profileUser = new ProfileDto(updatedUser); return(Ok(profileUser)); }
/// <summary> /// 修改指定字段,邮件和组别 /// </summary> /// <param name="id"></param> /// <param name="updateUserDto"></param> /// <returns></returns> public void UpdateUserInfo(int id, UpdateUserDto updateUserDto) { //此方法适用于更新字段少时 //_freeSql.Update<LinUser>(id).Set(a => new LinUser() //{ // Email = updateUserDto.Email, // GroupId = updateUserDto.GroupId //}).ExecuteAffrows(); //需要多查一次 LinUser linUser = _userRepository.Where(r => r.Id == id).ToOne(); if (linUser == null) { throw new LinCmsException("用户不存在", ErrorCode.NotFound); } //赋值过程可使用AutoMapper简化 //只更新 Email、GroupId // UPDATE `lin_user` SET `email` = ?p_0, `group_id` = ?p_1 // WHERE(`id` = 1) AND(`is_deleted` = 0) //linUser.Email = updateUserDto.Email; //linUser.GroupId = updateUserDto.GroupId; _mapper.Map(updateUserDto, linUser); _userRepository.Update(linUser); }
public IActionResult UpdateUser(long id, [FromBody] UpdateUserDto body) { // validate var ok = body.Validate(); if (ok != null) { return(BadRequest(ok)); } // Authorize user long tokenId = int.Parse(User.Claims.First(x => x.Type == "uid").Value); if (id != tokenId) { return new ObjectResult(new ForbiddenDto()) { StatusCode = 403 } } ; // Update user var user = body.ToDomain(); user.Id = id; _service.UpdateUser(user); return(Ok(new EmptyOkDto())); } }
public void Execute(UpdateUserDto request) { var user = context.Users.Include(u => u.UserUseCases).Where(x => x.Id == request.Id).First(); if (user == null) { throw new EntityNotFoundException(request.Id, typeof(User)); } foreach (var idUse in request.RemoveUserUseCases) { var usecase = context.UserUseCases.Where(u => u.UserId == request.Id && u.UseCaseId == idUse).First(); context.UserUseCases.Remove(usecase); } foreach (var idUse in request.UserUseCases) { context.UserUseCases.Add(new UserUseCase { UserId = request.Id, UseCaseId = idUse }); } context.SaveChanges(); }
public async Task <IActionResult> UpdateProfile(int id, UpdateUserDto userDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var profile = await _context.Users.Include(x => x.Role).Include(x => x.DoctorAppointments).FirstOrDefaultAsync(x => x.Id == id); if (profile == null) { return(NotFound()); } var authorizationResult = _authorizationService.AuthorizeAsync(User, profile, new ProfileRequirement()).Result; if (!authorizationResult.Succeeded) { return(Forbid()); } profile.Address = userDto.Address; profile.DateOfBirth = userDto.DateOfBirth; profile.Name = userDto.Name; await _context.SaveChangesAsync(); return(Ok()); }
public async Task <IActionResult> UpdateUser(int userId, UpdateUserDto updatedUser) { try { _logger.LogRequest("Updating user {userId}. Request body: {@updatedUser}", userId, updatedUser); var currentUserId = User.GetUserId(); if (currentUserId != userId && !User.IsInRole(UserRole.Administrator)) { _logger.LogWarning("User {currentUserId} is not authorized to access the endpoint", currentUserId); return(Unauthorized()); } if (userId != updatedUser.Id) { _logger.LogWarning("User Id doesn't match."); return(BadRequest("User Id doesn't match.")); } var user = _mapper.Map <User>(updatedUser); await _userService.UpdateUser(user); _logger.LogResponse("User {userId} updated", userId); return(Ok()); } catch (DuplicateUserNameException ex) { return(BadRequest(ex.Message)); } }
public void Execute(UpdateUserDto request) { var user = Context.Users.Find(request.Id); if (user == null || user.IsDeleted == true) { throw new EntityNotFoundException("User"); } if (request.FirstName == null || request.LastName == null || request.RoleId == 0 || request.Email == null) { throw new EntityCannotBeNullException("Fields"); } if (request.Email.ToLower() != user.Email.ToLower() && Context.Users.Any(u => u.Email.ToLower() == request.Email.ToLower())) { throw new EntityAlreadyExistsException("Email"); } if (request.RoleId == 2) { user.FirstName = request.FirstName; user.LastName = request.LastName; user.RoleId = request.RoleId; user.Email = request.Email; } else { user.FirstName = request.FirstName; user.LastName = request.LastName; user.Email = request.Email; } Context.SaveChanges(); }