public ActionResult Put([FromBody] UserUpdateData userData) { var userName = HttpContext.User.Claims.FirstOrDefault().Value; var user = context.Users.FirstOrDefault(x => x.UserName == userName); if (userData.Bio != null) { user.Bio = userData.Bio; } if (userData.Password != null) { user.Password = BCrypt.Net.BCrypt.HashPassword(userData.Password); } if (userData.TeamId != 0) { var team = context.Teams.FirstOrDefault(x => x.Id == userData.TeamId); if (team == null) { return(NotFound("Team does not exist")); } user.TeamId = team.Id; } context.Update(user); context.SaveChanges(); return(Ok(user)); }
async Task <IEnumerable <CardModel> > IStoreItemService.BuyStoreItemAsync(int id, int userId, CancellationToken cancellationToken) { var bundle = await _storeItemRepository.GetStoreItemById(id, cancellationToken : cancellationToken); if (bundle == null) { throw new InvalidStoreItemException($"Store item { id } not found in store."); } if (bundle.Expiry.HasValue && bundle.Expiry > DateTime.UtcNow) { throw new InvalidStoreItemException($"Store item { bundle.StoreItem.Name } has expired."); } var user = await _userRepository.GetUserByIdAsync(userId, cancellationToken : cancellationToken); if (user == null) { throw new InvalidPlayerException($"Player { userId } does not exist."); } if (user.Coins < bundle.StoreItem.Cost) { throw new InvalidPlayerException($"Player { userId } does not have enough coins."); } var userUpdate = new UserUpdateData { Coins = user.Coins - bundle.StoreItem.Cost, }; await _userRepository.UpdateUserAsync(userId, userUpdate, cancellationToken : cancellationToken); var cardResults = await _cardRepository.FindCardsAsync( new Data.Abstractions.CardSearchFilter { CardPackId = bundle.CardPackId, PageSize = int.MaxValue, }, cancellationToken : cancellationToken ); var allCards = cardResults .Results .SelectMany(x => Enumerable.Repeat(x, x.Rarity.Frequency)) .ToArray() ; var acl = allCards.Length; var ic = bundle.StoreItem.ItemCount; var cards = new CardModel[ic]; for (int i = 0; i < ic; i++) { cards[i] = allCards[RandomNumberGenerator.GetInt32(acl)]; } return(cards); }
public void Update(UserUpdateData userUpdateData) { using (var transactionScope = new TransactionScope()) { //ApplicationUser user = this.userManager.FindByName(userUpdateData.Username); //user.Email = userUpdateData.Email; //user.PhoneNumber = userUpdateData.Phone; //IdentityResult updateUserAccountResult = this.userManager.Update(user); //this.ProcessIdentityResult("Update User Account data", updateUserAccountResult); CEMUser userData = this.Select(userUpdateData.Id); userData = this.mapper.Map <UserUpdateData, CEMUser>(userUpdateData, userData); this.Save(userData); //IEnumerable<string> oldUserRoles = this.userManager.GetRoles(user.Id); //IdentityResult removeOldUserRolesResult = this.userManager.RemoveFromRoles(user.Id, oldUserRoles.ToArray()); //this.ProcessIdentityResult("Update User Roles", removeOldUserRolesResult); //IdentityResult addingUserRolesResult = this.userManager.AddToRoles(user.Id, userUpdateData.Roles.ToArray()); //this.ProcessIdentityResult("Update User Roles", addingUserRolesResult); transactionScope.Complete(); } }
public void OnActionExecuting(ActionExecutingContext context) { var jwtUser = context.HttpContext.User; if (!jwtUser.HasClaim(c => c.Type == JwtRegisteredClaimNames.Email)) { InvalidateRequest(context, "Invalid token for request", _logger, 401); } UserUpdateDataHolder userHolder = context.ActionArguments["userHolder"] as UserUpdateDataHolder; if (null == userHolder) { InvalidateRequest(context, "No user holder is present.", _logger, 422); } UserUpdateData user = userHolder.User; if (null == user) { InvalidateRequest(context, "No user is present in the user holder.", _logger, 422); } if (!context.ModelState.IsValid) { List <string> errors = context .ModelState .Values .SelectMany(e => e.Errors) .Select(e => e.ErrorMessage) .Distinct() .Cast <string>() .ToList(); InvalidateRequest(context, errors, _logger, 422); } }
public void UpdateUserAsync(UserUpdateData data, Action <ResponseBase, Exception> callback) { RpcRoot.JsonRpc.SignPostAsync( _controllerName, nameof(IUserController.UpdateUser), data, callback); }
public void DisplayNameTooLong() { UserUpdateData test = new UserUpdateData() { DisplayName = new string('a', 129), }; Assert.False(test.DataAnnotationIsValid()); }
public void PasswordTooShort() { UserUpdateData test = new UserUpdateData() { Password = string.Empty, }; Assert.False(test.DataAnnotationIsValid()); }
public void PasswordTooLong() { UserUpdateData test = new UserUpdateData() { Password = new string('a', 513), }; Assert.False(test.DataAnnotationIsValid()); }
public void EmailInvalid() { UserUpdateData test = new UserUpdateData() { Email = "email", }; Assert.False(test.DataAnnotationIsValid()); }
public void DisplayNameTooShort() { UserUpdateData test = new UserUpdateData() { DisplayName = string.Empty, }; Assert.False(test.DataAnnotationIsValid()); }
public void Update(UserUpdateData input) { if (_dicByLoginName.TryGetValue(input.LoginName, out UserData entity)) { entity.Update(input); _redis.SetAsync(entity).ContinueWith(t => { _mqSender.SendUserUpdated(input.LoginName); }); } }
internal override async Task <User> UpdateUser(string username, UserUpdateData updateData) { var transaction = _context.Database.BeginTransaction(); try { IdentityUser identityUser = await _userManager.FindByNameAsync(username); if (null != updateData.Username) { var result = await _userManager.SetUserNameAsync(identityUser, updateData.Username); if (!result.Succeeded) { throw new ConduitServerException($"Failed to update username of user with username {username}"); } } if (null != updateData.Email) { var result = await _userManager.SetEmailAsync(identityUser, updateData.Email); if (!result.Succeeded) { throw new ConduitServerException($"Failed to update email of user with username {username}"); } } if (null != updateData.Password) { var passwordHash = _userManager.PasswordHasher.HashPassword(identityUser, updateData.Password); identityUser.PasswordHash = passwordHash; var result = await _userManager.UpdateAsync(identityUser); if (!result.Succeeded) { throw new ConduitServerException($"Failed to update password of user with username {username}"); } } if (null != updateData.Bio) { _userPersonalizationRepository.UpdateUserBio(identityUser.Id, updateData.Bio); } if (null != updateData.Image) { _userPersonalizationRepository.UpdateUserImage(identityUser.Id, updateData.Image); } _context.SaveChanges(); transaction.Commit(); UserPersonalizationDAO userPersonalizationDTO = _userPersonalizationRepository.GetUserPersonalization(identityUser.Id); return(new User(identityUser.Email, GenerateJWTToken(identityUser), identityUser.UserName, userPersonalizationDTO.Bio, userPersonalizationDTO.Image)); } catch (Exception ex) { transaction.Rollback(); throw ex; } }
async Task IUserRepository.UpdateUserAsync(int id, UserUpdateData update, CancellationToken cancellationToken) { var existingUser = await _context.User.Where(x => x.UserPk == id).SingleOrDefaultAsync(cancellationToken: cancellationToken); if (existingUser == null) { throw new CardHeroDataException($"Player { id } does not exist."); } if (update.Coins.IsSet) { existingUser.Coins = update.Coins.Value; } await _context.SaveChangesAsync(cancellationToken : cancellationToken); }
public void UpdateUserTest() { //given User user1 = new User("John", "Lennon"); User user2 = new User("Mike", "Love"); User user3 = new User("Ringo", "Starr"); userDao.AddUser(user1); userDao.AddUser(user2); userDao.AddUser(user3); //when UserUpdateData data = new UserUpdateData(1, "Majk", "Bove"); userDao.UpdateUser(data); //then Assert.AreEqual(userDao.GetUser(1).FirstName, "Majk"); }
public HttpResponseMessage UsersUpdate(string name, [FromBody] UserUpdateData data) { HttpResponseMessage retVal; ParameterValidator validator = new ParameterValidator(ModelState); if (!User.IsInRole("Administrator") && (User.Identity.Name != name)) { retVal = Request.CreateResponse(HttpStatusCode.Unauthorized, "Insufficient rights to modify data for other Users."); } else if (!User.IsInRole("Administrator") && data.Role != null) { retVal = Request.CreateResponse(HttpStatusCode.Unauthorized, "Insufficient rights to modify User Role."); } else if (!validator.IsValid) { retVal = Request.CreateResponse(HttpStatusCode.BadRequest, validator.Result); } else if (data == null || (data.DisplayName == null && data.Email == null && data.Password == null && data.Role == null)) { retVal = Request.CreateResponse(HttpStatusCode.BadRequest, validator.AddError("data", "At least one updated field must be supplied.").Result); } else { IUser user = SecurityManager.FindUser(name); if (user != default(User)) { IResult <IUser> updateResult = SecurityManager.UpdateUser(user.Name, data.DisplayName, data.Email, data.Password, data.Role); if (updateResult.ResultCode != ResultCode.Failure) { retVal = Request.CreateResponse(HttpStatusCode.OK, new UserData(updateResult.ReturnValue), JsonFormatter()); } else { retVal = Request.CreateResponse(HttpStatusCode.InternalServerError, new HttpErrorResult($"Failed to update User '{name}'.", updateResult), JsonFormatter()); } } else { retVal = Request.CreateResponse(HttpStatusCode.NotFound); } } return(retVal); }
public void Constructor() { UserUpdateData test = new UserUpdateData() { DisplayName = "display name", Email = "*****@*****.**", Password = "******", Role = Role.Reader, }; Assert.IsType <UserUpdateData>(test); Assert.Equal("display name", test.DisplayName); Assert.Equal("*****@*****.**", test.Email); Assert.Equal("password", test.Password); Assert.Equal(Role.Reader, test.Role); Assert.True(test.DataAnnotationIsValid()); }
public ActionResult UpdateSomeone([FromBody] UserUpdateData userData, int id) { var user = context.Users.FirstOrDefault(u => u.Id == id); if (user == null) { return(NotFound()); } if (userData.Bio != null) { user.Bio = userData.Bio; } if (userData.Password != null) { user.Password = BCrypt.Net.BCrypt.HashPassword(userData.Password); } if (userData.TeamId != 0) { var team = context.Teams.FirstOrDefault(x => x.Id == userData.TeamId); if (team == null) { return(NotFound("Team does not exist")); } user.TeamId = team.Id; team.Members.Add(user); context.Update(team); } context.Update(user); context.SaveChanges(); return(Ok(user)); }
public void UpdateUserAsync(UserUpdateData data, Action <ResponseBase, Exception> callback) { JsonRpcRoot.SignPostAsync(RpcRoot.OfficialServerHost, RpcRoot.OfficialServerPort, _controllerName, nameof(IUserController.UpdateUser), data, callback); }
public void UpdateUser(UserUpdateData userData) { GetUser(userData.userId)?.UpdateUser(userData); }
public UserUpdateDataHolder(UserUpdateData userUpdateData) { User = userUpdateData; }
internal abstract Task <User> UpdateUser(string username, UserUpdateData user);
public void UpdateUser(UserUpdateData data) { libUOW.GetUsersDao.UpdateUser(data); }