public OAuthController(UsersDb usersDb, AppsDb appsDb,
IPasswordHasher passwordHasher, ITokenService tokenService)
{
_usersDb = usersDb;
_appsDb = appsDb;
_passwordHasher = passwordHasher;
_tokenService = tokenService;
if (!_usersDb.Users.Any())
{
_usersDb.Users.Add(new User
{
Username = "******",
Password = _passwordHasher.GenerateIdentityV3Hash("Password")
});
_usersDb.Users.Add(new User
{
Username = "******",
Password = _passwordHasher.GenerateIdentityV3Hash("Password")
});
_usersDb.SaveChanges();
}
if (!_appsDb.Users.Any())
{
_appsDb.Users.Add(new AppUser
{
client_id = "clientid",
appSecret = _passwordHasher.GenerateIdentityV3Hash("secret")
});
_appsDb.SaveChanges();
}
}
public async Task <IActionResult> Register(string userName, string email, string password)
{
string cltMsgText = "";
email = email.ToLower();
if (sc.IsNullOrEmptyOWhiteSpacer(userName) || sc.validateEmail(email) || sc.validatePassword(password))
{
// HttpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
return(BadRequest());
}
User user = await _dbRepo.GetItem <User>(email);
if (user != null)
{
cltMsgText = $"User with email: {email} alredy exists!";
// return StatusCode(409);
return(new ObjectResult(new { token = "", msg = cltMsgText }));
}
string hpassword = _passwordHasher.GenerateIdentityV3Hash(password);
user = new User {
Name = userName, Email = email, Password = hpassword
};
await _dbRepo.AddItem(user, true);
var atoken = GenerateJSONWebToken(user);
return(new ObjectResult(new { token = atoken, msg = "" }));
}
public async Task <IActionResult> Register(string username, string password)
{
var user = new IdentityUser {
UserName = username, Email = username
};
user.EmailConfirmed = true;
var result = await _userManager.CreateAsync(user, password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
// add user
var refreshUser = _context.UserRefreshTokens.SingleOrDefault(u => u.Username == username);
if (refreshUser != null)
{
return(StatusCode(409));
}
_context.UserRefreshTokens.Add(new UserRefreshToken
{
Username = username,
Password = _passwordHasher.GenerateIdentityV3Hash(password)
});
await _context.SaveChangesAsync();
refreshUser = _context.UserRefreshTokens.SingleOrDefault(u => u.Username == username);
return(Ok(refreshUser));
}
return(BadRequest("Could not register user."));
}
public async Task <DTO.User> Execute(UserCredentials user)
{
await ValidateUserExists(user);
user.Role = "Default";
user.Password = _PasswordHasher.GenerateIdentityV3Hash(user.Password);
return(await _UsersRepository.Create(user));
}
public IHttpActionResult Create(CreateUserRequestDTO dto)
{
dto.Password = _passwordHasher.GenerateIdentityV3Hash(dto.Password);
this.Servicio.Create(dto);
return(Ok());
}
public AccountController(UsersDb usersDb, IPasswordHasher passwordHasher, ITokenService tokenService)
{
_usersDb = usersDb;
_passwordHasher = passwordHasher;
_tokenService = tokenService;
if (!_usersDb.Users.Any())
{
_usersDb.Users.Add(new User
{
Username = "******",
Password = _passwordHasher.GenerateIdentityV3Hash("Password")
});
_usersDb.Users.Add(new User
{
Username = "******",
Password = _passwordHasher.GenerateIdentityV3Hash("Password")
});
_usersDb.SaveChanges();
}
}
public async Task AddUsuario(AutenticaModel model)
{
try
{
model.Senha = _passwordHasher.GenerateIdentityV3Hash(model.Senha);
await _context.Autentica.AddAsync(model);
_context.SaveChanges();
}
catch (Exception ex)
{
throw new Exception($"Erro para salvar o cadastro! {ex.Message}");
}
}
public async Task <IActionResult> Signup([FromBody] User sentUser)
{
var user = _context.Users.SingleOrDefault(u => u.Email == sentUser.Email);
if (user != null)
{
return(StatusCode(409, Json(sentUser.Email + " already exists.")));
}
var refreshToken = _tokenService.GenerateRefreshToken();
var pass = _passwordHasher.GenerateIdentityV3Hash(sentUser.Password);
var jwtToken = string.Empty;
try
{
var newUser = new User
{
RefreshToken = refreshToken,
Username = sentUser.Username,
Email = sentUser.Email,
Password = pass
};
// add to DB
_context.Users.Add(newUser);
await _context.SaveChangesAsync();
_log.LogInformation($"New user was created {newUser.Id}");
//access Id of newly inserted entity
var usersClaims = new[]
{
new Claim(ClaimTypes.Name, newUser.Username),
new Claim("UserId", newUser.Id)
};
jwtToken = _tokenService.GenerateAccessToken(usersClaims);
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
return(new ObjectResult(new
{
token = jwtToken,
refreshToken
}));
}
public async Task <AccountInforDto> ChangePasswordAsync(Guid id, string password)
{
var user = await _unitOfWork.UserRepository.FindByIdAsync(id);
if (user != null)
{
return(null);
}
// Keep old password
user.PasswordHash = _passwordHasher.GenerateIdentityV3Hash(password);
// Hash password
_unitOfWork.UserRepository.Update(user);
await _unitOfWork.SaveChangesAsync();
return(new AccountInforDto
{
Id = user.Id,
UserName = user.UserName,
Email = user.Email
});
}
public async Task <IActionResult> Signup([FromBody] Users user)
{
Users x = userDataProvider.GetUserByUsername(user.Email).Result;
//var user = _usersDb.Users.SingleOrDefault(u => u.Username == username);
if (x != null)
{
return(StatusCode(409));
}
user.Password = _passwordHasher.GenerateIdentityV3Hash(user.Password);
await this.userDataProvider.AddUser(user);
return(Ok(user));
}
public async Task <IActionResult> Signup([FromBody] vmRegisterUserRequest registerUser)
{
var validEmailResponse = await _commonService.CheckSingleUserExistedAsync(registerUser.Email);
if (validEmailResponse.Message.Equals(ResponseMessageDisplay.Found))
{
return(validEmailResponse.ToHttpResponse());
}
else
{
registerUser.Password = _passwordHasher.GenerateIdentityV3Hash(registerUser.Password);
var registerUserResponse = await _commonService.RegisterNewUser(registerUser);
return(registerUserResponse.ToHttpResponse());
}
}
public async Task <IActionResult> Register(UserDto userDto)
{
var user = _dataContext.Users.SingleOrDefault(x => x.UserName == userDto.UserName);
if (user != null)
{
return(StatusCode(409));
}
_dataContext.Users.Add(new User
{
UserName = userDto.UserName,
Password = _passwordHasher.GenerateIdentityV3Hash(userDto.Password),
Email = userDto.Email
});
await _dataContext.SaveChangesAsync();
return(StatusCode(201));
}
public async Task <ActionResult> Signup([FromBody] User us)
{
var user = _usersDb.Users.SingleOrDefault(u => u.Username == us.Username);
if (user != null)
{
return(StatusCode(409));
}
_usersDb.Users.Add(new User
{
Username = us.Username,
Password = _passwordHasher.GenerateIdentityV3Hash(us.Password)
});
await _usersDb.SaveChangesAsync();
return(Ok(user));
}
public ActionResult InsertUser([FromBody] RegisterViewModel model)
{
if (_repository.GetByEmail(model.Email) != null)
{
return(BadRequest());
}
var user = new User()
{
Email = model.Email,
Phone = model.Phone,
FirstName = model.FirstName,
LastName = model.LastName,
PasswordHash = _passwordHasher.GenerateIdentityV3Hash(model.Password)
};
_repository.Add(user);
return(Ok(user));
}
public async Task <IActionResult> Signup(string username, string password)
{
var user = _usersDb.Users.SingleOrDefault(u => u.Username == username);
if (user != null)
{
return(StatusCode(StatusCodes.Status409Conflict));
}
_usersDb.Users.Add(new User
{
Username = username,
Password = _passwordHasher.GenerateIdentityV3Hash(password)
});
await _usersDb.SaveChangesAsync();
return(Ok(user));
}
public async Task <IActionResult> Signup([FromBody] SignupVm signupVm)
{
//check if user already exists
var existingUser = await _accountService.GetUser(signupVm.Email);
if (existingUser != null)
{
return(new BadRequestObjectResult(AccountError.UserAlreadyExist));
}
//create passwordhash for storing in db
var passwordHash = _passwordHasher.GenerateIdentityV3Hash(signupVm.Password);
var user = _mapper.Map <User>(signupVm);
user.PasswordHash = passwordHash;
user.Type = UserType.Doctor; // assuming only doctor will use this service to register
var newUserId = await _accountService.AddUser(user);
return(Ok(newUserId));
}
public IActionResult Register([FromBody] User user)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var exist = _context.User.FirstOrDefault(u => u.User_Name == user.User_Name);
if (exist != null)
{
return(BadRequest("El nombre de usuario ya existe!"));
}
user.User_Role = "User";
// Hashing the password and creating the tokens
user.User_Password = _passowrdHasher.GenerateIdentityV3Hash(user.User_Password);
string tokenAccess = _tokensService.CreateAccessToken(user);
var newUserSession = new UserRefreshToken {
Password = user.User_Password,
UserName = user.User_Name,
RefreshToken = _tokensService.CreateRefreshToken()
};
// Storing the data
using ( _context )
{
_context.User.Add(user);
_context.UserRefreshToken.Add(newUserSession);
_context.SaveChanges();
}
return(Created("api/auth/login", new
{
access_token = tokenAccess,
refresh_token = newUserSession.RefreshToken
}));
}
public async Task AddUser(User user)
{
user.Password = _passwordHasher.GenerateIdentityV3Hash(user.Password);
_dbContext.Users.Add(user);
await _dbContext.SaveChangesAsync();
}
