public async Task <IActionResult> UpdateUser(int id, [FromBody] UserSaveResource userResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await userRepo.GetUser(id, false);
if (user == null)
{
return(NotFound());
}
mapper.Map <UserSaveResource, User>(userResource, user);
await uow.CompleteAsync();
user = await userRepo.GetUser(user.Id);
var result = mapper.Map <User, UserSaveResource>(user);
return(Ok(result));
}
public async Task <ActionResult <UserResource> > UpdateUser(int id, [FromBody] UserSaveResource user)
{
var validator = new UserSaveResourceValidator();
var validationResult = await validator.ValidateAsync(user);
var requestIsInvalid = id == 0 || !validationResult.IsValid;
if (requestIsInvalid)
{
return(BadRequest(validationResult.Errors)); // this needs refining, but for demo it is ok
}
var userToBeUpdate = await _userService.GetById(id);
if (userToBeUpdate == null)
{
return(NotFound());
}
var mappedUser = _mapper.Map <UserSaveResource, User>(user);
await _userService.UpdateUser(userToBeUpdate, mappedUser);
var updatedUser = await _userService.GetById(id);
var updatedUserResource = _mapper.Map <User, UserResource>(updatedUser);
return(Ok(updatedUserResource));
}
public async Task <IActionResult> Register([FromBody] UserSaveResource userSaveResource)
{
var response = await _userService.Create(userSaveResource);
if (!response.Success)
{
return(BadRequest(response.Error));
}
return(CreatedAtAction(nameof(Register), new { id = response.Result.Id }, response.Result));
}
public async Task <IActionResult> Update(int id, [FromBody] UserSaveResource userSaveResource)
{
var response = await _userService.Update(id, userSaveResource);
if (!response.Success && response.Error.Status == 404)
{
return(NotFound(response.Error));
}
if (!response.Success)
{
return(BadRequest(response.Error));
}
return(Ok(response.Result));
}
public async Task <UserResponse> Update(int id, UserSaveResource user)
{
var userExist = await _userRepository.FindByIdAsync(id);
if (userExist == null)
{
return(new UserResponse(404, "User id not found", "Id", "User not found."));
}
if (userExist.Email != user.Email)
{
var userExistUsername = await _userRepository.FindByEmail(user.Email);
// username has changed so check if the new username is already taken
if (userExistUsername != null)
{
return(new UserResponse(400, "User already exists", "Username", "Email " + user.Email + " is already taken"));
}
}
// update user properties
userExist.FirstName = user.FirstName;
userExist.LastName = user.LastName;
userExist.Email = user.Email;
try
{
// update password if it was entered
if (!string.IsNullOrWhiteSpace(user.Password))
{
byte[] passwordHash, passwordSalt;
CreatePasswordHash(user.Password, out passwordHash, out passwordSalt);
userExist.PasswordHash = passwordHash;
userExist.PasswordSalt = passwordSalt;
}
_userRepository.Update(userExist);
var userResource = _mapper.Map <User, UserResource>(userExist);
return(new UserResponse(userResource));
}
catch (Exception ex)
{
return(new UserResponse(400, "Unexpected error", "Error", ex.Message));
}
}
public async Task <UserResponse> Create(UserSaveResource userSave)
{
// validation
if (string.IsNullOrWhiteSpace(userSave.Password))
{
return(new UserResponse(400, "Password required", "Password", "Password is required."));
}
var userExist = await _userRepository.FindByEmail(userSave.Email);
if (userExist != null)
{
return(new UserResponse(400, "User already exists", "Email", "Email " + userSave.Email + " is already taken"));
}
try
{
byte[] passwordHash;
byte[] passwordSalt;
CreatePasswordHash(userSave.Password, out passwordHash, out passwordSalt);
var user = _mapper.Map <UserSaveResource, User>(userSave);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _userRepository.AddAsync(user);
var userResource = _mapper.Map <User, UserResource>(user);
return(new UserResponse(userResource));
}
catch (ArgumentNullException ex)
{
return(new UserResponse(400, "Invalid password", "Password", ex.Message));
}
catch (ArgumentException ex)
{
return(new UserResponse(400, "Invalid password", "Password", ex.Message));
}
catch (Exception ex)
{
return(new UserResponse(400, "Unexpected error", "Error", ex.Message));
}
}
public async Task <IActionResult> Register([FromBody] UserSaveResource user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (await _authRepo.UserExist(user.Email))
{
return(BadRequest("Email is already registered!"));
}
user.Deactive = true;
var userToCreate = _mapper.Map <UserSaveResource, User>(user);
await _authRepo.Register(userToCreate, user.Password);
await _uow.CompleteAsync();
return(StatusCode(201));
}
public IActionResult Login([FromBody] UserSaveResource userAccount)
{
var userFromDb = userManager.FindByEmailAsync(userAccount.Email).Result;
var result = signInManager.CheckPasswordSignInAsync(userFromDb, userAccount.Password, false).Result;
if (result.Succeeded)
{
var tokenString = GenerateJSONWebToken(userFromDb);
return(Ok(new
{
userFromDb.Id,
userFromDb.Email,
userFromDb.UserName,
Roles = userManager.GetRolesAsync(userFromDb).Result,
tokenString
}));
}
return(Unauthorized());
}
public IActionResult RegisterUser([FromBody] UserSaveResource userAccount)
{
var user = new User()
{
Email = userAccount.Email,
UserName = userAccount.UserName
};
userManager.CreateAsync(user, userAccount.Password).Wait();
var registeredUser = userManager.FindByNameAsync(user.UserName).Result;
userManager.AddToRoleAsync(registeredUser, Policies.Moderator).Wait();
return(Ok(new
{
registeredUser.Id,
registeredUser.Email,
registeredUser.UserName,
Roles = userManager.GetRolesAsync(registeredUser).Result,
}));
}
public async Task <ActionResult <UserResource> > CreateUser([FromBody] UserSaveResource user)
{
var validator = new UserSaveResourceValidator();
var validationResult = await validator.ValidateAsync(user);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors)); // this needs refining, but for demo it is ok
}
var userToCreate = _mapper.Map <UserSaveResource, User>(user);
userToCreate.Statistics = new Statistics()
{
NumberOfGamesPlayed = 0, SuccesfullGames = 0, TimeInGames = 0
};
var newUser = await _userService.CreateUser(userToCreate);
var createdUser = await _userService.GetById(newUser.Id);
var userResource = _mapper.Map <User, UserResource>(createdUser);
return(Ok(userResource));
}
