public static void UpdateUser(UpdateUserRequestModel model) { var connection = new SqlConnection(GlobalSettings.ConnectionString); connection.Open(); var commandString = @"UPDATE [User] SET Name=@Name, Lastname=@Lastname, PhoneNumber=@PhoneNumber WHERE Id=@Id" ; using (var command = new SqlCommand(commandString, connection)) { command.Parameters.AddWithValue("@Name", model.Name); command.Parameters.AddWithValue("@Lastname", model.Lastname); command.Parameters.AddWithValue("@PhoneNumber", model.PhoneNumber); command.Parameters.AddWithValue("@Id", model.UserId); command.ExecuteNonQuery(); } connection.Close(); }
public void PutTest() { User user = GetUser(); UpdateUserRequestModel userRequest = GetUpdateUserRequestModel(); UserResponseModel userResponse = GetUserResponseModel(); ValidationResponse <User> validationResponse = GetOkValidationResponse(); _mockMapper .Setup(mapper => mapper.Map <UpdateUserRequestModel, User>(userRequest)) .Returns(user); _mockService .Setup(serv => serv.Update(user)) .Returns(validationResponse); _mockMapper .Setup(mapper => mapper.Map <User, UserResponseModel>(validationResponse.ResponseData)) .Returns(userResponse); IActionResult actionResult = _controller.Put(_userId, userRequest); OkObjectResult actual = (OkObjectResult)actionResult; string actualName = ((UserResponseModel)actual.Value).FullName; Assert.Equal(user.FullName, actualName); Assert.Equal(StatusCodes.Status200OK, actual.StatusCode); }
public async Task <ResultModel <bool> > UpdateUser(string userId, UpdateUserRequestModel model) { var user = await GetById(userId); if (user == null) { return(new ResultModel <bool> { Errors = { UserErrors.InvalidUserId } }); } user.Biography = model.Biography; // In case the user deteles his display name. I need it because I render it on the front-end (the header). user.DisplayName = string.IsNullOrWhiteSpace(model.DisplayName) || model.DisplayName == "" ? user.DisplayName = user.UserName : user.DisplayName = model.DisplayName; user.Email = model.Email; user.ProfilePictureUrl = model.ProfilePictureUrl; this.dbContext.Update(user); await this.dbContext.SaveChangesAsync(); return(new ResultModel <bool> { Result = true, Success = true, }); }
public async Task <ActionResult <UserDto> > Update(UpdateUserRequestModel model) { var user = await _repository.Update(User.GetId(), model); return(user != null ? Accepted(nameof(Update), model) : StatusCode(StatusCodes.Status500InternalServerError, null)); }
public Task <IActionResult> Update([FromBody] UpdateUserRequestModel model) { return(HandleCommand(new UpdateUserCommand { UserId = User.GetId(), Model = model })); }
public int Update(UpdateUserRequestModel model) { var user = _repo.GetById(model.Id); user.Age = model.Age; user.Login = model.Name; return(_repo.Update(user)); }
public async Task <ActionResult> UpdateUser([FromBody] UpdateUserRequestModel input) { var userId = this.User.GetId(); await this.identityService.UpdateUserAsync(userId, input.FullName, input.UserName, input.ImageUrl); return(this.Ok()); }
public async Task <IActionResult> UpdateUserByIdObjectAsParam(Guid id, UpdateUserRequestModel userRequestModel) { //*****************Calls update controller on Identity API, so the db is synced*************************** //var identityBaseurl = _identityConfig.Value.IdentityServerUrl + "/identity/users/" + id; var identityBaseurl = "https://localhost:5001/identity/users/" + id; var httpClient = new HttpClient(); httpClient.DefaultRequestHeaders .Accept .Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json")); var jsonUpdateStatement = JsonConvert.SerializeObject(new UpdateIdentityUser { Email = userRequestModel.Email, Password = userRequestModel.Password, AuthLevel = userRequestModel.AccessLevel, }, Formatting.Indented); var httpContent = new StringContent(jsonUpdateStatement, System.Text.Encoding.UTF8, "application/json"); var identityResult = await httpClient.PutAsync(identityBaseurl, httpContent); if (!identityResult.IsSuccessStatusCode) { return(StatusCode(400, "Identity server could not be reached.")); } //*********************Update API db (seperate from identity db)************************ //Gets user from database to handle null and empty variables in the request model var user = await QueryRouter.QueryAsync <GetUserById, User>(new GetUserById(id)); //if the variables are empty or null, (or 0 for access level), they wont be updated if (user != null) { if (string.IsNullOrWhiteSpace(userRequestModel.Name) && !string.IsNullOrWhiteSpace(user.Name)) { userRequestModel.Name = user.Name; } if (string.IsNullOrWhiteSpace(userRequestModel.Email) && !string.IsNullOrWhiteSpace(user.Email)) { userRequestModel.Email = user.Email; } if (userRequestModel.AccessLevel == 0) { userRequestModel.AccessLevel = user.AccessLevel; } if (userRequestModel.Wage == 0) { userRequestModel.Wage = user.BaseWage; } } var result = await CommandRouter.RouteAsync <UpdateUserCommand, IdResponse>( new UpdateUserCommand(userRequestModel.Name, userRequestModel.Email, userRequestModel.Password, userRequestModel.AccessLevel, userRequestModel.Wage, userRequestModel.EmploymentDate, id)); return(new ObjectResult(result)); }
public async Task <UserResponseModel> UpdateAsync(int id, UpdateUserRequestModel updateUserRequestModel) { const string actionName = nameof(UpdateAsync); updateUserRequestModel = updateUserRequestModel ?? throw new ArgumentNullException(nameof(updateUserRequestModel)); if (id != updateUserRequestModel.Id) { throw new InconsistentException(nameof(updateUserRequestModel)); } var username = await _userManager.Users.AnyAsync(x => x.UserName == updateUserRequestModel.UserName && x.Id != id); if (username) { throw new DataAlreadyException(updateUserRequestModel.UserName); } var email = await _userManager.Users.AnyAsync(x => x.Email == updateUserRequestModel.Email && x.Id != id); if (email) { throw new DataAlreadyException(updateUserRequestModel.Email); } var listRole = updateUserRequestModel.Role; var _user = await _userManager.FindByIdAsync(id.ToString()); var roles = await _userManager.GetRolesAsync(_user); foreach (var role in listRole) { if (await _userManager.IsInRoleAsync(_user, role) == false) { await _userManager.AddToRoleAsync(_user, role); } else { foreach (var item in roles) { if (!item.Contains(role)) { await _userManager.RemoveFromRoleAsync(_user, item); } } } } Logger.LogDebug(LoggingMessage.ProcessingInService, actionName, seviceName, updateUserRequestModel); var user = await _userRepository.GetAsync(id); _Mapper.Map(updateUserRequestModel, user); var respone = await _userRepository.UpdateAsync(user, true); Logger.LogInfomation(LoggingMessage.ActionSuccessfully, actionName, seviceName, respone); return(_Mapper.Map <UserResponseModel>(respone)); }
public async Task <IHttpActionResult> Put(UpdateUserRequestModel model) { var authenticatedUser = this.User.Identity.GetUserId(); var updateUserResult = await this.usersServices.Update( authenticatedUser, model.Email); return(this.Ok(updateUserResult)); }
/// <summary> /// Updates the user profile. /// </summary> /// <param name="updatedUserProfile">The updated user profile(new profile).</param> public void UpdateProfile([FromBody] UpdateUserRequestModel updatedUserProfile) { user = new UserDto { ID = updatedUserProfile.UserID, Password = updatedUserProfile.Password, Email = updatedUserProfile.Email, Image = updatedUserProfile.Image, }; userManger.UpdateUserProfile(user); }
public async Task <IActionResult> UpdateUser(int id, [FromBody] UpdateUserRequestModel user) { await _userRepository.Update(new User { Id = id, Email = user.Email, Name = user.Name, Surname = user.Surname }); return(Ok()); }
public async Task <IActionResult> UpdateUser(Guid id, [FromBody] UpdateUserRequestModel requestModel) { //apparently Guids can be made 'nullable', so a null check is made, although guid is a value type and thus cannot be null pr. default if (id == Guid.Empty || id == null) { return(StatusCode(400)); } var result = await _userHandler.UpdateUser(id, requestModel); return(StatusCode(!result.IsSuccessful ? 400 : 200, result.Message)); }
public async Task <ActionResult> UpdateUserInformation(UpdateUserRequestModel model) { string userId = this.User.GetId(); Result result = await this.identityService.UpdateUserInformation(model.FirstName, model.LastName, model.Birthday, model.Mobile, model.FacebookUrl, model.FavoriteSport, userId); if (!result.Succeeded) { return(BadRequest(result.Error)); } return(Ok()); }
public async Task <ActionResult> Update(string userId, [FromBody] UpdateUserRequestModel model) { var updateRequest = await this.usersService.UpdateAsync(userId, model); if (!updateRequest.Success) { return(this.BadRequest(new ErrorsResponseModel { Errors = updateRequest.Errors, })); } return(this.Ok()); }
public async Task <ActionResult> Update(UpdateUserRequestModel model) { var userId = this.User.GetId(); var updated = await this.identityService.EditUser(userId, model.Name, model.City, model.Address, model.Country, model.Avatar); if (!updated) { return(BadRequest()); } return(Ok()); }
public async Task <UserDto> Update(string id, UpdateUserRequestModel model) { var user = await _userManager.FindByIdAsync(id); user.FirstName = model.FirstName; user.OtherName = model.OtherName; user.LastName = model.LastName; user.PhoneNumber = model.PhoneNumber; _db.Users.Update(user); await _db.SaveChangesAsync(); return(await GetById(user.Id)); }
public async Task UpdateAsync(UpdateUserRequestModel requestModel) { var user = await userRepository.GetByCPFAsync(requestModel.CPF); switch (user != null) { case true: { await userRepository.UpdateAsync(mapper.Map <UserModel>(requestModel)); break; } case false: throw new Exception("The user doenst exists."); } }
public async Task <ActionResult <UserResponseModel> > UpdateAsync(int id, [FromBody] UpdateUserRequestModel updateUserRequestModel) { const string actionName = nameof(UpdateAsync); if (id != updateUserRequestModel.Id) { throw new InconsistentException(nameof(updateUserRequestModel)); } Logger.LogDebug(LoggingMessage.ProcessingRequestWithModel, actionName, updateUserRequestModel); var response = await _userAppService.UpdateAsync(id, updateUserRequestModel); Logger.LogInfomation(LoggingMessage.RequestResults, actionName); return(Ok(response)); }
public async Task <IActionResult> UpdateUser([FromBody] UpdateUserRequestModel model) { var user = await _userService.UpdateUserAsync(model); if (user == null) { return(BadRequest(new { message = "Kullanici güncellenirken hata oluştu!" })); } var resModel = new ByNameResponseModel() { UserName = user.UserName }; return(Ok(resModel)); }
public async Task <User> UpdateUserAsync(UpdateUserRequestModel model) { var user = await _userRepository.GetByIdAsync(model.Id); if (user != null) { user.UserName = model.UserName; user.Email = model.Email; user.Address = model.Address; user.Email = model.Email; user.Password = model.Password; _userRepository.Update(user); } return(user); }
public async Task <MiscResponse <UserResponseModel> > UpdateUserAsync(UpdateUserRequestModel model) { var existingUser = this._userRepo.Find(x => x.Id == model.Id).FirstOrDefault(); if (existingUser == null) { throw new ArgumentException($"A user does not exist with the given id '{model.Id}'"); } if (!string.IsNullOrWhiteSpace(model.Email)) { var existingUserWithEmail = this._userRepo.Find(x => x.Email == model.Email && x.Id != model.Id); if (existingUserWithEmail.Any()) { throw new ArgumentException($"A user already exists with the updated email '{model.Email}'"); } existingUser.Email = model.Email; } if (string.IsNullOrWhiteSpace(model.Name)) { existingUser.Name = model.Name; } if (string.IsNullOrWhiteSpace(model.Password)) { existingUser.Salt = generateSalt(); existingUser.PasswordHash = hashPassword(model.Password, existingUser.Salt); var userTokens = this._userTokenRepo.Find(x => x.UserId == model.Id).ToList(); var updates = userTokens.Select(x => this._userTokenRepo.DeleteAsync(x)).ToArray(); Task.WaitAll(updates); } if (model.IsAdmin.HasValue) { existingUser.IsAdmin = model.IsAdmin.Value; } await this._userRepo.UpdateAsync(existingUser); return(new MiscResponse <UserResponseModel> { Data = existingUser.ToModel(), Message = "User updated successfully" }); }
public UpdateUserResponseModel UpdateUser(UpdateUserRequestModel model) { var response = new UpdateUserResponseModel(); try { UserManager.UpdateUser(model); response.IsSuccess = true; response.Message = "Başarılı"; } catch (Exception ex) { response.IsSuccess = false; response.Message = ex.Message; } return(response); }
public async Task <ActionResult> UpdateUser(string userId, UpdateUserRequestModel model) { var loggedUserId = this.User.GetId(); if (loggedUserId != userId) { return(Unauthorized(UserErrors.UserHaveNoPermissionToUpdate)); } var result = await this.userService.UpdateUser(loggedUserId, model); if (!result.Success) { return(BadRequest(result.Errors)); } return(Ok(result.Result)); }
public async Task <UserResponseModel> UpdateUser(UpdateUserRequestModel model) { var updatedUser = new Users { Id = model.Id, Email = model.Email, Fullname = model.Fullname, Password = model.Password, JoinedOn = model.JoinedOn }; await _userRepository.UpdateAsync(updatedUser); var userResponseModel = new UserResponseModel { Id = updatedUser.Id, Fullname = updatedUser.Fullname }; return(userResponseModel); }
public async Task <ActionResult> UpdateUserAsync([FromBody] UpdateUserRequestModel userModel) { if (!Guid.TryParse(userModel.Id, out var userId)) { return(BadRequest()); } var user = await _userRepository.FindOrDefaultAsync(userId); if (user == null) { return(NotFound(new { Message = $"User with id {userModel.Id} not found." })); } user.SetUserInformation(userModel.CurrencyId, userModel.CountryId); _userRepository.Update(user); await _userRepository.UnitOfWork.SaveChangesAsync(); return(CreatedAtAction(nameof(GetByIdAsync), new { id = user.Id.ToString() }, null)); }
public async Task <Response> UpdateUser(Guid id, UpdateUserRequestModel updateUserRequestModel) { var user = await _userRepository.GetUser(id); if (!string.IsNullOrWhiteSpace(updateUserRequestModel.Password)) { user.Password = BCrypt.Net.BCrypt.HashPassword(updateUserRequestModel.Password); } if (!string.IsNullOrWhiteSpace(updateUserRequestModel.Email)) { user.Email = updateUserRequestModel.Email; } if (updateUserRequestModel.AuthLevel != 0) { user.AuthLevel = updateUserRequestModel.AuthLevel; } return(await _userRepository.UpdateUser(user)); }
public void PutUserAlreadyExistTest() { User user = GetUser(); UpdateUserRequestModel userRequest = GetUpdateUserRequestModel(); ValidationResponse <User> validationResponse = GetFailedValidationResponse(); _mockMapper .Setup(mapper => mapper.Map <UpdateUserRequestModel, User>(userRequest)) .Returns(user); _mockService .Setup(serv => serv.Update(user)) .Returns(validationResponse); IActionResult actionResult = _controller.Put(_userId, userRequest); BadRequestObjectResult actual = (BadRequestObjectResult)actionResult; Assert.Equal(StatusCodes.Status400BadRequest, actual.StatusCode); }
public async Task <User> UpdateUser(UpdateUserRequestModel request) { var user = await _userRepo.GetUser(request.UserId); if (user == null) { return(user); } user.FirstName = request.FirstName; user.LastName = request.LastName; user.Email = request.Email; user.PhoneNumber = request.PhoneNumber; user = await _userRepo.UpdateUser(user); await BuildUpUser(user); return(user); }
/// <summary> /// Update /// </summary> /// <param name="userRequestModel"></param> /// <param name="ct"></param> /// <returns></returns> public async Task <UserResponseModel> UpdateUserAsync(UpdateUserRequestModel userRequestModel, int agencyId, CancellationToken ct = default) { User user = await _userRepository.GetAll().Include(x => x.Employee) .Where(x => x.Id == userRequestModel.Id && x.Employee.AgencyId == agencyId) .FirstOrDefaultAsync(ct); if (user is null) { throw new UserNotFoundException(); } user = _mapper.Map(userRequestModel, user); _userRepository.Update(user); await _unitOfWork.SaveChangesAsync(ct); var data = _mapper.Map <UserResponseModel>(user); return(data); }