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);
}
