public async Task <IActionResult> Login(UserToLogin userToLogin)
{
var user = await _repo.Login(userToLogin.UserName, userToLogin.Password);
if (user == null)
{
return(Unauthorized());
}
var claims = new []
{
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
new Claim(ClaimTypes.Name, user.UserName),
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_Config.GetSection("AppSetting:Token").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokendescriper = new SecurityTokenDescriptor {
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddSeconds(2 * 60),
SigningCredentials = creds
};
var TokenHandler = new JwtSecurityTokenHandler();
var token = TokenHandler.CreateToken(tokendescriper);
return(Ok(new { token = TokenHandler.WriteToken(token) }));
}
public async Task <Json> Delete(long id, [FromBody] UserToLogin user)
{
if (id <= 0 ||
user == null)
{
return(Json.BadRequest("Este usuáro não é válido!", user));
}
var repository = UserRepository.GetInstance(_context);
var userToDelete = repository.GetById(id);
if (!repository.EmailValidation(user.Email) ||
userToDelete == null)
{
return(Json.NotFound("Este usuáro não é válido!", user));
}
var result = await repository.Delete(user.Email, user.Password);
if (result.Erro)
{
return(Json.BadRequest("Falha ao deletar usuário!", result.Description));
}
userToDelete = repository.GetById(id);
if (userToDelete.Result.Active)
{
return(Json.BadRequest("Falha ao deletar usuário!", userToDelete));
}
return(Json.Ok("Usuário Apagado com sucesso!", null));
}
public UserToLoginResponse loginUser(UserToLogin userToLogin)
{
var usrFromDb = _datingAppContext.Usuarios.FirstOrDefault(x => x.Username == userToLogin.Username);
if (usrFromDb == null)
{
return(null);
}
if (!comparePasswords(userToLogin.Password, usrFromDb.PassHash, usrFromDb.PassSalt))
{
return(null);
}
var claims = new[] {
new Claim(ClaimTypes.NameIdentifier, usrFromDb.Cedula),
new Claim(ClaimTypes.Name, usrFromDb.Username)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration.GetSection("AddSection:myKey").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor()
{
Subject = new ClaimsIdentity(claims),
SigningCredentials = creds,
Expires = DateTime.Now.AddDays(1)
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
var myToken = tokenHandler.WriteToken(token);
UserToLoginResponse userToLoginResponse = new UserToLoginResponse()
{
Token = myToken
};
return(userToLoginResponse);
}
private async Task <LoginToResponse> Login(UserToLogin userLogin, SigningConfigurations signingConfigurations, TokenConfiguration tokenConfigurations)
{
if (userLogin.Email.IsEmail() && !string.IsNullOrEmpty(userLogin.Password))
{
var repository = UserRepository.GetInstance(_context);
var user = await repository.GetUserLogin(userLogin.Email, userLogin.Password);
if (user != null)
{
var token = GenerateToken.TokenGenerate(user.Email, signingConfigurations, tokenConfigurations);
var userDisplay = user.ToDisplay();
if (user.Admin)
{
var repositoryBusiness = EstablishmmentRepository.GetInstance(_context);
userDisplay.Establishmments = repositoryBusiness.GetByAdmin(user.Id).ToDisplay();
}
return(LoginToResponse.Create(userDisplay, token));
}
}
return(null);
}
public IActionResult Authenticate([FromBody] UserToLogin userToLogin)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = _repository.Authenticate(userToLogin);
if (user == null)
{
return(BadRequest("Incorrect combination of email and/or password"));
}
var tokenString = _repository.CreateToken(user);
var userWithToken = new UserWithToken {
Id = user.Id,
Name = user.Name,
Email = user.Email,
Token = tokenString,
Role = user.Role.ToString()
};
return(Ok(userWithToken));
}
public LoginResult Login(UserToLogin user)
{
_logger.Info($"Attempt to login for '{user.Email}'");
AdditionalLoginInfo additionalInfo = _securityRepository.GetAdditionalLoginInfo(user.Email);
if (additionalInfo == null)
{
_logger.Info($"User was not found: '{user.Email}'");
return(new LoginResult(ErrorCodeType.MemberNotFound));
}
if (!_membership.ValidateUser(additionalInfo.Username, user.Password))
{
_logger.Info($"User was not approved or password is not correct: '{user.Email}'");
return(new LoginResult(ErrorCodeType.MemberIsNotApprovedOrInvalidCredentials));
}
if (!_securityRepository.IsEmailConfirmed(user.Email))
{
_logger.Info($"User has not confirmed an email: '{user.Email}'");
return(new LoginResult(ErrorCodeType.MemberHasNotConfirmedEmail));
}
var type = (LoginType)additionalInfo.LoginType;
if (type == LoginType.TwoFactorViaEmail)
{
var provider = _serviceContainer.GetInstance <ITwoFactorLoginProvider>(new ConstructorParameter("userEmail", user.Email));
provider.Process(additionalInfo.UserId);
}
return(new LoginResult(additionalInfo.Username, type));
}
public async Task <ActionResult <UsertoDisplay> > Login(UserToLogin loginDto)
{
var user = await _userManager.Users
.SingleOrDefaultAsync(x => x.Email == loginDto.Email.ToLower());
if (user == null)
{
return(Unauthorized("Pogrešan email"));
}
var result = await _signInManager
.CheckPasswordSignInAsync(user, loginDto.Password, false);
if (!result.Succeeded)
{
return(Unauthorized());
}
return(new UsertoDisplay
{
Id = user.Id,
Username = user.Ime + " " + user.Prezime,
Role = (await _userManager.GetRolesAsync(user)).FirstOrDefault(),
Token = await GenerateJwtToken(user),
});
}
public async Task <TokenToReturn> LoginAsync(UserToLogin userToLogin)
{
userToLogin.UserName = userToLogin.UserName.ToLower();
var userFromRepo = await _userRepo.GetSingleAsync(userToLogin.UserName);
if (userFromRepo == null)
{
throw new Exception("Wrong credentials.");
}
var result = await _signInManager
.CheckPasswordSignInAsync(userFromRepo, userToLogin.Password, false);
if (!result.Succeeded)
{
throw new Exception("Error occurred");
}
var userToReturn = _mapper.Map <UserDetail>(userFromRepo);
var tokenToReturn = new TokenToReturn
{
Token = await _tokenService.CreateTokenAsync(userFromRepo),
User = userToReturn
};
return(tokenToReturn);
}
public async Task <IActionResult> Login([FromBody] UserToLogin userToLogin)
{
var userFromRepo = await _repo.Login(userToLogin.Username.ToLower(), userToLogin.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
//generate token
var tokenHandler = new JwtSecurityTokenHandler();
//var key = Encoding.ASCII.GetBytes(_config.GetSection("AppSettings:Token").Value);
var key = Encoding.ASCII.GetBytes("super secret key"); //zmiana bo testowy hostserver nie radzi sobie z czytaniem appsettings
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, userFromRepo.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.Username)
}),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha512Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
var toReturn = new
{
TokenString = tokenString,
User = userFromRepo
};
return(Ok(toReturn));
}
public async Task <IActionResult> Login(UserToLogin userToLogin)
{
var user = await repository.Login(userToLogin.Username.ToLower(), userToLogin.Password);
if (user == null)
{
return(Unauthorized());
}
var claims = new [] {
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
new Claim(ClaimTypes.Name, user.Username),
new Claim(ClaimTypes.Email, user.EmailAddress),
new Claim(ClaimTypes.GivenName, string.Format("{0} {1}", user.Firstname, user.Lastname))
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(config.GetSection("AppSettings:Token").Value));
var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor {
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = credentials
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(new { token = tokenHandler.WriteToken(token) }));
}
public async Task <IActionResult> SignIn([FromBody] UserToLogin aUser)
{
if (ModelState.IsValid)
{
return(Ok(await _loginServices.SignIn(aUser)));
}
return(NotFound());
}
public IActionResult Login(UserToLogin userToLogin)
{
userToLogin.Username = userToLogin.Username.ToLower();
var userLogged = _authRepository.loginUser(userToLogin);
if (userLogged == null)
{
return(Unauthorized());
}
return(Ok(userLogged)); /* Returns Token */
}
public async Task <IActionResult> LoginAsync(UserToLogin userToLogin)
{
try
{
return(Ok(await _service.LoginAsync(userToLogin)));
}
catch (Exception e)
{
return(Unauthorized(e.Message));
}
}
public async Task <IActionResult> LoginUser([FromBody] UserToLogin userToLogin)
{
var result = await _authService.LoginUser(userToLogin.Email, userToLogin.Password);
if (!result.Success)
{
return(Unauthorized("User not found or password is invalid"));
}
return(Ok(result));
}
public void AuthService_Login_UserDoesNotExist_Failure()
{
// Arrange
ErrorCodeType expectedErrorCode = ErrorCodeType.MemberNotFound;
UserToLogin user = GetUserToLogin();
// Act
LoginResult loginResult = _authService.Login(user);
// Assert
AssertExpectedFailureResultForLogin(loginResult, expectedErrorCode);
}
public async Task <LoggedInUser> SignIn(UserToLogin aUser)
{
var result = await _userManager.FindByEmailAsync(aUser.Email);
if (result != null)
{
var confirmed = await _userManager.CheckPasswordAsync(result, aUser.Password);
if (!confirmed)
{
throw new NullReferenceException("Wrong Password");
}
await _signInManager.PasswordSignInAsync(result, aUser.Password, true, true);
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, result.Id),
new Claim(ClaimTypes.Name, result.LastName)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration.GetSection("AppSettings:Token").Value));
var credential = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var securityTokenDescriptor = new SecurityTokenDescriptor()
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = credential
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(securityTokenDescriptor);
var myToken = tokenHandler.WriteToken(token);
var user = new LoggedInUser
{
LastName = result.LastName,
FirstName = result.FirstName,
Email = result.Email,
Photo = result.Photo,
Token = myToken,
ExpiryDate = securityTokenDescriptor.Expires
};
return(user);
}
throw new NullReferenceException("User not found");
}
public object LoginUser(UserToLogin userToLogin)
{
var user = new
{
Id = 1,
UserName = "******",
FirstName = "Jason",
LastName = "John",
Email = "*****@*****.**"
};
return(user);
}
public async Task <IActionResult> Login([FromBody] UserToLogin userLoginDto)
{
var userFromRepo = await _repo.Login(userLoginDto.Email, userLoginDto.Password);
if (userFromRepo.Status != "Approve")
{
return(Unauthorized("In Review"));
}
if (userFromRepo == null)
{
return(Unauthorized("No Record Found!"));
}
else
{
var claim = new[]
{
new Claim(ClaimTypes.NameIdentifier, userFromRepo.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.Name),
new Claim(ClaimTypes.Email, userFromRepo.Email),
new Claim(ClaimTypes.Role, userFromRepo.Level),
new Claim(ClaimTypes.Authentication, userFromRepo.Status)
};
//Create Token
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config.GetSection("AppSetting:Token").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claim),
Expires = DateTime.Now.AddDays(60),
SigningCredentials = creds
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(new
{
token = tokenHandler.WriteToken(token)
}));
}
}
public async Task <IActionResult> Login(UserToLogin user)
{
var userFromRepo = await _repo.Login(user.Name.ToLower(), user.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
var secret = _config.GetSection("My_Custom_Settings:Token").Value;
var token = new JWTToken(userFromRepo, secret);
return(Ok(new { token = token.Build() }));
}
public void AuthService_Login_ExistingUser_InvalidCredentialsOrUserIsNotApproved_Failure()
{
// Arrange
ErrorCodeType expectedErrorCode = ErrorCodeType.MemberIsNotApprovedOrInvalidCredentials;
UserToLogin user = GetUserToLogin();
ReturnExistingAdditionalInfo(user.Email);
ReturnInvalidUserValue(Username, user.Password);
// Act
LoginResult loginResult = _authService.Login(user);
// Assert
AssertExpectedFailureResultForLogin(loginResult, expectedErrorCode);
}
public async Task <IActionResult> Login(UserToLogin user)
{
//throw new Exception("... Exception from 'controller/login' ...");
var userFromRepo = await _repo.Login(user.Name.ToLower(), user.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
var secret = _config.GetSection("Cembo_Settings:Token").Value;
var token = new JWTToken(userFromRepo, secret);
return(Ok(new { token = token.Build() }));
}
public User Authenticate(UserToLogin userToLogin)
{
if (string.IsNullOrEmpty(userToLogin.Email) || string.IsNullOrEmpty(userToLogin.Password))
{
return(null);
}
var user = _context.Users.SingleOrDefault(u => u.Email == userToLogin.Email);
if (user == null)
{
return(null);
}
if (!VerifyPasswordHash(userToLogin.Password, user.PasswordHash, user.PasswordSalt))
{
return(null);
}
return(user);
}
private void AuthService_Login_ValidLoginProcess(LoginType type)
{
// Arrange
LoginType expectedLoginType = type;
UserToLogin user = GetUserToLogin();
ReturnExistingAdditionalInfo(user.Email, type);
ReturnValidUserValue(Username, user.Password);
ReturnConfirmedEmailValue(user.Email);
// Act
LoginResult loginResult = _authService.Login(user);
// Assert
Assert.IsNotNull(loginResult, Common.ShowResponseTypeMismatchMessage(typeof(LoginResult)));
Assert.IsTrue(loginResult.IsSuccess, Common.ShowNotSatisfiedExpectationMessage(true, "loginResult.IsSuccess"));
Assert.AreEqual(expectedLoginType, loginResult.Type, Common.ShowNotSatisfiedExpectationMessage(expectedLoginType, loginResult.Type));
Assert.AreEqual(Username, loginResult.Username, Common.ShowNotSatisfiedExpectationMessage(Username, loginResult.Username));
}
public async Task <Json> PostLogin([FromBody] UserToLogin userLogin, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfiguration tokenConfigurations)
{
var user = await Login(userLogin, signingConfigurations, tokenConfigurations);
if (user != null)
{
var userResponse = LoginToResponse.Create(user.User, user.Token);
return(Json.Ok("Usuário Validado e autenticado!.", userResponse));
}
else
{
if (Get(userLogin.Email).StatusCode.Value.Equals(200))
{
return(Json.NotFound("Senha inválida", false));
}
return(Json.NotFound("Usuário não cadastrado!", false));
}
}
public async Task <IActionResult> Login(UserToLogin userToLogin)
{
if (userToLogin != null && !string.IsNullOrEmpty(userToLogin.Username))
{
var userFromRepo = await _repo.Login(userToLogin.Username.ToLower(), userToLogin.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
var claims = new[] {
new Claim(ClaimTypes.NameIdentifier, userFromRepo.id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.Username)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config.GetSection("AppSettings:Token").Value));
var cred = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.UtcNow.AddHours(1),
SigningCredentials = cred
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
var currentUser = _mapper.Map <UserForListDto>(userFromRepo);
return(Ok(new
{
token = tokenHandler.WriteToken(token),
currentUser
}));
}
else
{
return(Unauthorized());
}
}
public async Task <IActionResult> Login(UserToLogin userToLogin)
{
var user = await _userManager.FindByNameAsync(userToLogin.Username);
if (user == null)
{
return(Unauthorized());
}
var result = await _signInManager.CheckPasswordSignInAsync(user, userToLogin.Password, false);
if (result.Succeeded)
{
return(Ok(
new {
token = GenerateJwtToken(user),
user = user
}
));
}
return(Unauthorized());
}
public IActionResult Authenticate([FromBody] UserToLogin userToLogin)
{
var user = _repository.Authenticate(userToLogin);
if (user != null)
{
if (userToLogin.IsAdmin)
{
if (user.Role != Role.Admin)
{
return(BadRequest("User not allowed, Please login as a normal user"));
}
}
else
{
if (user.Role != Role.User)
{
return(BadRequest("Please login as admin to get access"));
}
}
}
if (user == null)
{
return(BadRequest("Incorrect combination of email and/or password"));
}
var tokenString = _repository.CreateToken(user);
var userWithToken = new UserWithToken {
Id = user.Id,
Name = user.Name,
Email = user.Email,
Token = tokenString,
Role = user.Role.ToString()
};
return(Ok(userWithToken));
}
public async Task <Json> PostCreate([FromBody] UserToCreate userSend, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfiguration tokenConfigurations)
{
var repositoy = UserRepository.GetInstance(_context);
if (repositoy.EmailValidation(userSend.Email))
{
return(Json.Conflit("Este email está sendo utilizado por outro usuário", userSend));
}
var userValidate = userSend.ToValidate();
if (userValidate.Erro)
{
return(Json.Conflit("Erro ao validar usuário, verifique os erros", userValidate.Erros));
}
var userCreate = await repositoy.Create(userSend.ToUserData());
if (userCreate.Erro)
{
return(Json.Conflit("Falha ao criar usuário!", userCreate.Description));
}
var userLogin = UserToLogin.Create(userSend.Email, userSend.Password);
var login = await Login(userLogin, signingConfigurations, tokenConfigurations);
if (login == null)
{
return(Json.BadRequest("Falha ao criar usuário", userSend));
}
var userResponse = LoginToResponse.Create(login.User, login.Token);
return(Json.Ok("Ususário criado com sucesso!", userResponse));
}
public async Task <IActionResult> Login(UserToLogin userToLogin)
{
//throw new Exception("This is not Handled Exception");
var loggedInUser = await _authRepository.Login(userToLogin.UserName.ToLower(), userToLogin.Password);
if (loggedInUser == null)
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, loggedInUser.Id.ToString()),
new Claim(ClaimTypes.Name, loggedInUser.UserName)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration.GetSection("Authorization:Token").Value));
var cred = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDesciptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = cred
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDesciptor);
return(Ok(new {
token = tokenHandler.WriteToken(token),
message = "Logged In Successull"
}));
}
