public async Task <IActionResult> SignIn(UserLoginResource userLoginResource)
{
try
{
var user = _userManager.Users.SingleOrDefault(u => u.UserName == userLoginResource.Email);
if (user is null)
{
return(NotFound("Usuário não encontrado."));
}
var userSigninResult = await _userManager.CheckPasswordAsync(user, userLoginResource.Password);
if (userSigninResult)
{
var roles = await _userManager.GetRolesAsync(user);
return(Ok(GenerateJwt(user, roles)));
}
return(BadRequest("Email ou senha incorreto."));
}
catch (Exception ex)
{
Log.Logger.Error(ex, "AuthController > SignIn - Erro Interno");
return(InternalServerError());
}
}
public async Task <IActionResult> SignIn(UserLoginResource userLoginResource)
{
var user = _userManager.Users.SingleOrDefault(u => u.UserName == userLoginResource.Email);
if (user is null)
{
return(NotFound("User not found"));
}
var userSigninResult = await _userManager.CheckPasswordAsync(user, userLoginResource.Password);
if (userSigninResult)
{
var roles = await _userManager.GetRolesAsync(user);
var refreshToken = GenerateRefreshToken();
user.RefreshToken = refreshToken;
user.RefreshTokenExpiryTime = DateTime.Now.AddMinutes(10);
await _userManager.UpdateAsync(user);
return(new ObjectResult(new
{
accessToken = GenerateJwt(user, roles),
refreshToken = refreshToken
}));
}
return(BadRequest("Email or password incorrect."));
}
public async Task <OutputHandler> SignIn(UserLoginResource userLoginResource)
{
var user = _userManager.Users.SingleOrDefault(u => u.UserName == userLoginResource.Email);
if (user is null)
{
return(new OutputHandler
{
IsErrorOccured = true,
Message = "Email or password incorrect.Please Check and try again"
});
}
var userSigninResult = await _userManager.CheckPasswordAsync(user, userLoginResource.Password);
if (userSigninResult)
{
var roles = await _userManager.GetRolesAsync(user);
return(new OutputHandler
{
IsErrorOccured = false,
Message = $"{user.Email}",
Result = GenerateJwt(user, roles)
});
}
return(new OutputHandler
{
IsErrorOccured = true,
Message = "Email or password incorrect.Please Check and try again"
});
}
public async Task <IActionResult> PostAsync([FromBody] UserLoginResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
string username = resource.Name;
string md5password = Helpers.CreateMD5(resource.Password);
User client = await _userRepository.GetByName(username);
if (client == null)
{
return(NotFound("User not found"));
}
if (client.Password != md5password)
{
return(Unauthorized("Incorrect credentials"));
}
string token = GenerateToken(client);
AuthTokenResource tokenResponse = new AuthTokenResource();
tokenResponse.Token = token;
return(Ok(tokenResponse));
}
public async Task <UserTokenResource> Login([FromBody] UserLoginResource login)
{
var user = await _service.LoginPlayer(login.Username, login.Password);
return(new UserTokenResource
{
Username = user.Username,
Fullname = user.FullName,
Token = user.Token
});
}
public async Task <User> LoginAsync(UserLoginResource credentials)
{
var user = await _context.Users.FirstOrDefaultAsync(u => u.UserName == credentials.Username.ToLower());
if (user == null || !_hashHelper.VerifyPasswordHash(credentials.Password, user.PasswordHash, user.PasswordSalt))
{
return(null);
}
return(user);
}
public async Task <IActionResult> Login()
{
UserLoginResource userLogin = new UserLoginResource
{
OutputHandler = new OutputHandler
{
IsErrorOccured = false
}
};
return(View(userLogin));
}
public async Task <IActionResult> SignIn(UserLoginResource userLoginResource)
{
var output = await _authenticationService.SignIn(userLoginResource);
if (output.IsErrorOccured)
{
return(BadRequest(output));
}
else
{
return(Ok(output));
}
}
public async Task <IActionResult> Login(UserLoginResource loginCredentials)
{
var requestUrl = $"{BaseUrl}{apiUriAccount}/SignIn";
OutputHandler outputHandler = new OutputHandler();
//Get Sermons
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(requestUrl);
HttpResponseMessage response = await client.PostAsJsonAsync(requestUrl, loginCredentials);
if (response.StatusCode == HttpStatusCode.OK)
{
outputHandler = await response.Content.ReadAsAsync <OutputHandler>();
if (!outputHandler.IsErrorOccured)
{
HttpContext.Session.Clear();
HttpContext.Session.SetString(LoggedInUser, outputHandler.Message);
HttpContext.Session.SetString(Token, outputHandler.Result.ToString());
var sessionDetails = await StaticDataHandler.GetSessionDetails();
if (sessionDetails.IsSet)
{
return(RedirectToAction("Index", "Dashboard"));
}
else
{
UserLoginResource userLogin = new UserLoginResource
{
OutputHandler = new OutputHandler {
IsErrorOccured = true, Message = "Login was successful, System has experienced a technical fault, Contact TechArch"
}
};
return(View(userLogin));
}
}
}
;
outputHandler = await response.Content.ReadAsAsync <OutputHandler>();
};
UserLoginResource userLoginResource = new UserLoginResource
{
OutputHandler = new OutputHandler {
IsErrorOccured = true, Message = outputHandler.Message
}
};
return(View(userLoginResource));
}
public async Task <IActionResult> Login([FromBody] UserLoginResource credentials)
{
var user = await _repository.LoginAsync(credentials);
if (user == null)
{
return(Unauthorized());
}
var token = _jwtFactory.GenerateEncodedToken(user.Id);
var refreshToken = _tokenFactory.GenerateToken();
// TODO: Save refresh token in db for renew
return(Ok(new { token, refreshToken }));
}
public async Task <IActionResult> Login([FromBody] UserLoginResource userLogin)
{
if (string.IsNullOrEmpty(userLogin.Account) || string.IsNullOrEmpty(userLogin.PassWord))
{
return(NotFound());
}
var user = await _userRepository.UserLoginAync(userLogin.Account, userLogin.PassWord.ToMd5Caps16());
if (user == null)
{
return(NotFound("用户名或密码错误"));
}
var userResult = _mapper.Map <UserResource>(user);
userResult.Token = _jwtServcie.CreateToken(user.Id.ToString(), user.Account);
return(Ok(userResult));
}
public async Task <ActionResult> SignIn(UserLoginResource userLoginResource)
{
var user = _userManager.Users.SingleOrDefault(u => u.UserName == userLoginResource.Email);
if (user is null)
{
return(NotFound("User not found"));
}
var userSignInResult = await _userManager.CheckPasswordAsync(user, userLoginResource.Password);
if (userSignInResult)
{
return(Ok());
}
return(BadRequest("Email or password incorrect."));
}
public async Task <IActionResult> Login([FromBody] UserLoginResource clientLogin)
{
if (clientLogin == null)
{
return(BadRequest("Invalid client request"));
}
if (clientLogin.UserName == "admin" && clientLogin.Password == "1234") // Only for test purposes
{
var tokenString = await loginRepository.Login();
return(Ok(new { token = tokenString }));
}
else
{
return(Unauthorized());
}
}
public async Task <IActionResult> LoginAsync([FromBody] UserLoginResource userLogin)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var response = await _authenticationService.CreateAccessTokenAsync(userLogin.Email, userLogin.Password);
if (!response.Success)
{
return(BadRequest(response.Message));
}
var accessTokenResource = _mapper.Map <AccessToken, AccessTokenResource>(response.Resource);
return(Ok(accessTokenResource));
}
public async Task <IActionResult> Authenticate([FromBody] UserLoginResource user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var authResponse = await authService.AuthenticateAsync(user.Login, user.Password);
var result = mapper.Map <User, UserResource>(authResponse.User);
return(Ok(
new ResponseData {
Success = authResponse.Success,
Message = authResponse.Message,
Data = result
}
));
}
public async Task <IActionResult> SignIn(UserLoginResource userLoginResource)
{
// Email exits ?
var user = _userManager.Users.SingleOrDefault(u => u.Email == userLoginResource.Email);
//List<UserRole> list = new List<UserRole>();
//UserRole userRole = new UserRole();
if (user is null)
{
return(NotFound("User not found"));
}
// Check Password
var userSigninResult = await _userManager.CheckPasswordAsync(user, userLoginResource.Password);
List <string> roles = new List <string>();
if (userSigninResult)
{
TokenRequestResource newTokenRequest = new TokenRequestResource();
newTokenRequest.Email = user.Email;
newTokenRequest.Password = userLoginResource.Password;
var listRoles = await _userManager.GetRolesAsync(user);
foreach (var role in listRoles)
{
Role newRole = new Role();
newRole.Name = role;
roles.Add(newRole.Name);
}
newTokenRequest.Roles = roles;
var tokenRequest = _mapper.Map <TokenRequestResource, TokenRequest>(newTokenRequest);
var result = await _tokenService.GetToken(tokenRequest, _jwtSettings);
var tokenRequestResource = _mapper.Map <TokenRequest, TokenRequestResource>(result);
return(Ok(tokenRequestResource));
}
return(BadRequest("Email or password incorrect."));
}
public async Task <IActionResult> SignIn(UserLoginResource userLoginResource)
{
var appUser = _userManager.Users.SingleOrDefault(u => u.UserName == userLoginResource.Email);
if (appUser is null)
{
return(NotFound("Usuario no encontrado"));
}
var userSigninResult = await _userManager.CheckPasswordAsync(appUser, userLoginResource.Password);
if (userSigninResult)
{
var roles = await _userManager.GetRolesAsync(appUser);
return(Ok(GenerateJwt(appUser, roles)));
}
return(BadRequest("Email o contraseña incorrect@."));
}
public async Task <IActionResult> LogIn(UserLoginResource userResource)
{
var user = _userManager.Users.SingleOrDefault(u => u.UserName == userResource.Email);
if (user is null)
{
return(NotFound("User not found"));
}
var LoginResult = await _userManager.CheckPasswordAsync(user, userResource.Password);
if (LoginResult)
{
//return Ok();
var roles = await _userManager.GetRolesAsync(user);
return(Ok(GenerateToken(user, roles)));
}
return(BadRequest("Email or password incorrect."));
}
public async Task <IActionResult> SignIn(UserLoginResource userLoginResource)
{
var user = _userManager.Users.SingleOrDefault(u => u.Email == userLoginResource.Email);
if (user is null)
{
return(NotFound("User not found"));
}
var userSigninResult = await _userManager.CheckPasswordAsync(user, userLoginResource.Password);
if (userSigninResult)
{
var roles = await _userManager.GetRolesAsync(user);
JwtResponse response = new JwtResponse(GenerateJwt(user, roles), new UserDto(user.Id, user.Email, user.firstName, user.lastName));
return(Ok(response));
}
return(BadRequest("Email or password incorrect."));
}
public async Task <IActionResult> SignIn(UserLoginResource userLoginResource)
{
var user = _userManager.Users.SingleOrDefault(u => u.UserName == userLoginResource.Email);
if (user is null)
{
return(NotFound("User not found"));
}
var userSigninResult = await _userManager.CheckPasswordAsync(user, userLoginResource.Password);
if (userSigninResult)
{
var roles = await _userManager.GetRolesAsync(user);
userLoginResource.Token = GenerateJwt(user, roles);
userLoginResource.Roles = roles;
userLoginResource.Id = user.Id.ToString();
return(Ok(userLoginResource));
}
return(BadRequest("Email or password incorrect."));
}
public async Task <IActionResult> Login(UserLoginResource userForLoginDto)
{
var userFromRepo = await _authRepo.Login(userForLoginDto.Username.ToLower(), userForLoginDto.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
// some claims to store in the token
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 creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(new {
token = tokenHandler.WriteToken(token)
}));
}
