public async Task <IActionResult> Login(UserToLoginDto userToLoginDto)
{
var userFromRepo = await _authRepository.Login(userToLoginDto.Username.ToLower(), userToLoginDto.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
var claims = new []
{
new Claim(ClaimTypes.NameIdentifier, userFromRepo.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.Name)
};
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)
}));
}
public async Task <IActionResult> Login([FromBody] UserToLoginDto userToLoginDto)
{
var userLoginResponse = await _authRepo.Login(userToLoginDto);
if (userLoginResponse == null)
{
return(Unauthorized());
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_config.GetSection("AppSettings:EncryptionKey").Value);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, userLoginResponse.Id.ToString()),
new Claim(ClaimTypes.Name, userLoginResponse.Email)
}),
Expires = DateTime.UtcNow.AddDays(1),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key),
SecurityAlgorithms.HmacSha512Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
userLoginResponse.RefreshToken = tokenString;
return(Ok(userLoginResponse));
}
public async Task <IActionResult> Login(UserToLoginDto userToLoginDto)
{
// provide the credentials to the Login method and if user doesn`t exist, then we return null.
//var userFromRepo = await _authRepository.Login(userToLoginDto.Username.ToLower(), userToLoginDto.Password);
var user = await _userManager.FindByNameAsync(userToLoginDto.Username);
// Will get the user found by the username and it will compare the password, and then we say false as we dont need to lock out our user.
var result = await _signInManager.CheckPasswordSignInAsync(user, userToLoginDto.Password, false);
// If null return unauthorized
if (result.Succeeded)
{
// This is used to retrieve the main photo, we mapp to UserForListDto
var appUser = _mapper.Map <UserForListDto>(user);
return(Ok(
new
{
token = GenerateJwtToken(user).Result,
user = appUser // this is what we return, so that we dont return the excesive information
}));
}
return(Unauthorized());
}
private async void GoToHomePage(object sender, EventArgs args)
{
SessionServices sessionServices = new SessionServices();
UserServices userServices = new UserServices();
UserToLoginDto user = new UserToLoginDto()
{
Email = email.Text,
Password = password.Text
};
List <UserDto> u = await userServices.GetUserByEmailAsync(email.Text);
register.IsEnabled = false;
login.IsEnabled = false;
login.Text = "Logging in...";
string token = await sessionServices.CreateSessionAsync(user);
if (token != "")
{
Application.Current.Properties["IdUser"] = u[0].ID;
Application.Current.Properties["Token"] = token;
await Navigation.PushModalAsync(new MainPage(), true);
}
else
{
error.IsVisible = true;
register.IsEnabled = true;
login.IsEnabled = true;
login.Text = "Login";
}
}
/// <summary>
/// Signs in user
/// </summary>
/// <param name="userToLogin">Username and password of user</param>
/// <returns>Generated token or errors that occured during sign in process</returns>
public async Task <IServiceResult <string> > LoginAsync(UserToLoginDto userToLogin)
{
try
{
UserModel user = (await _unitOfWork.Users.GetByExpressionAsync(x => x.UserName.ToLower() == userToLogin.Username.ToLower())).SingleOrDefault();
if (user != null)
{
SignInResult loginResult = await _signInManager.CheckPasswordSignInAsync(user, userToLogin.Password, false);
if (loginResult.Succeeded)
{
IList <string> usersRoles = await _signInManager.UserManager.GetRolesAsync(user);
using (IJsonWebTokenProvider jwtProvider = new JsonWebTokenProvider(_configuration))
{
string token = jwtProvider.GenerateJwtBearer(user, usersRoles);
return(new ServiceResult <string>(ResultType.Correct, token));
}
}
}
return(new ServiceResult <string>(ResultType.Error, new List <string> {
"Incorrect username or password"
}));
}
catch (Exception e)
{
return(new ServiceResult <string>(ResultType.Unauthorized, new List <string> {
e.Message
}));
}
}
public async Task <ActionResult <EUser> > Login([FromForm] UserToLoginDto userToLogin)
{
var loggedUser = await _userService.Login(userToLogin);
// Check if user passed auth
if (loggedUser.HasError)
{
// Show error to user
ViewData["modalMessage"] = loggedUser.Message;
return(View());
}
// Baking JWT token
string token = _tokenService.CreateToken(loggedUser.UserId, loggedUser.UserRoles);
// Storing token and username in cookies
var cookieOptions = new CookieOptions()
{
HttpOnly = true,
SameSite = SameSiteMode.Strict
};
// Constructing cookies to set
var cookiesData = new Dictionary <string, string>()
{
["X-Access-Token"] = token,
["X-Username"] = userToLogin.Email
};
// Setting cookies from data
_cookiesService.SetCookies(cookiesData, cookieOptions, Response);
return(Redirect("/user/getAllUsers"));
}
public async Task <IActionResult> Login(UserToLoginDto userToLoginDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userToLog = await _repo.Login(userToLoginDto.Username.ToLower(), userToLoginDto.Password);
if (userToLog == null)
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, userToLog.Id.ToString()),
new Claim(ClaimTypes.Name, userToLog.Username)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration.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);
var user = _mapper.Map <UserForListDto>(userToLog);
return(Ok(new
{
token = tokenHandler.WriteToken(token), //write out token into the response that we are sending back to the client
user
}));
}
public async Task <IActionResult> Login(UserToLoginDto account)
{
var user = await _auth.Login(account.Username, account.Password);
if (user == null)
{
return(Unauthorized("Sai tên đăng nhập hoặc mật khẩu, vui lòng thử lại"));
}
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
new Claim(ClaimTypes.Name, user.Username),
new Claim(ClaimTypes.Role, user.Role)
};
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) }));
}
async Task LoginToMenu()
{
var user = new UserToLoginDto
{
UserName = Login,
Password = this.Password
};
try
{
LoggedUserDto loggedUser = await _api.Login(user);
if (loggedUser.UserType == "P")
{
ShowViewModel <MenuPoliceViewModel>();
_userDialogs.Alert("Logged as Police");
}
else if (loggedUser.UserType == "U")
{
ShowViewModel <MenuViewModel>();
_userDialogs.Alert("Logged as User");
}
else
{
ShowViewModel <MenuPoliceViewModel>();
//_userDialogs.Alert("Logged as Admin");
}
}
catch (Exception ex)
{
_userDialogs.Alert(ex.Message);
}
}
public async Task <UserActionResult> Login(UserToLoginDto userToLogin)
{
var user = await GetUserByEmailAsync(userToLogin.Email);
UserActionResult result;
if (String.IsNullOrEmpty(userToLogin.Email) || String.IsNullOrEmpty(userToLogin.Password))
{
string messageFailed = $"Email and password must not be empty.";
_logger.LogWarning(messageFailed);
result = InitResult(0, null, true, messageFailed);
return(result);
}
// if username not found
if (user == null)
{
string messageFailed = $"Login failed for '{userToLogin.Email}'. Username or password incorrect.";
_logger.LogWarning(messageFailed);
result = InitResult(0, null, true, messageFailed);
return(result);
}
using var hmac = new HMACSHA512(user.PasswordSalt);
var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(userToLogin.Password));
for (int i = 0; i < computedHash.Length; i++)
{
if (user.PasswordHash[i] != computedHash[i])
{
string messageFailed = $"Login failed for '{userToLogin.Email}'. Username or password incorrect.";
_logger.LogWarning(messageFailed);
result = InitResult(0, null, true, $"Login failed for '{userToLogin.Email}'. Username or password incorrect.");
return(result);
}
}
// Update login stats
user.LastLoginUTC = DateTime.UtcNow;
user.LoginsCount++;
await _dbcontext.SaveChangesAsync();
// Get user roles
var userRoles = await GetUserRolesAsync(user.id);
string messageSuccess = $"User '{userToLogin.Email}' has been succesfully logged in.";
_logger.LogInformation(messageSuccess);
result = InitResult(user.id, userRoles, false, messageSuccess);
return(result);
}
public async Task <IActionResult> Login(UserToLoginDto userToLogin)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var UserLogged = await _repo.Login(userToLogin.username, userToLogin.password);
if (UserLogged == null)
{
return(Unauthorized()); // BadRequest("User or password doesn't match!");
}
// Payload: User info
var Claims = new[]
{
//new Claim(ClaimTypes.NameIdentifier, UserLogged.Id.ToString()),
new Claim(ClaimTypes.Name, UserLogged.UserName)
};
// Generate SSK Key
var jkey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config.GetSection("AppSetting:Token").Value));
//Signing key
var creds = new SigningCredentials(jkey, SecurityAlgorithms.HmacSha512Signature);
//Token Descriptor
var tokenDescription = new SecurityTokenDescriptor()
{
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds,
Subject = new ClaimsIdentity(Claims)
};
// // Finally create a Token
// var header = new JwtHeader(creds);
// //Some PayLoad that contain information about the customer
// var payload = new JwtPayload
// {
// { "userId ", UserLogged.Id.ToString()},
// { "username", UserLogged.UserName},
// };
//
// var secToken = new JwtSecurityToken(header, payload);
var tokenHandler = new JwtSecurityTokenHandler();
// var token = tokenHandler.WriteToken(secToken);
var token = tokenHandler.CreateToken(tokenDescription);
return(Ok(new {
token = tokenHandler.WriteToken(token) //token
}));
}
public async Task <IActionResult> Login(UserToLoginDto request)
{
ServiceResponse <string> response = await _authRepo.Login(request.Username, request.password);
if (!response.Success)
{
return(BadRequest(response));
}
return(Ok(response));
}
/// <summary>
///
/// </summary>
/// <param name="userToLoginDto"></param>
/// <returns></returns>
public async Task <string> LoginUser(UserToLoginDto userToLoginDto)
{
var user = await GetUserByEmail(userToLoginDto.Email);
var roles = await GetUserRoles(user);
await _signManager.SignInAsync(user, false);
return(JwtTokenConfig.GetToken(user, _config, roles));
}
public async Task <string> CreateSessionAsync(UserToLoginDto user)
{
GetClient();
string session = "";
HttpResponseMessage response = await client.PostAsJsonAsync("api/session/", user);
if (response.IsSuccessStatusCode)
{
session = await response.Content.ReadAsStringAsync();
}
return(session);
}
public async Task <IActionResult> Login(UserToLoginDto userToLogin)
{
var user = await _userService.LoginUserAsync(userToLogin);
if (user == null)
{
return(Unauthorized("Incorrect user or password"));
}
var token = _security.GenerateToken(user);
return(Ok(token));
}
public async Task <User> AddUser(UserToLoginDto user)
{
if (!(await _userRepository.UserExists(user.Username)))
{
var role = await _roleRepository.GetDefaultRole();
var userTosave = _mapper.Map <User>(user);
userTosave.Role = role;
return(await _userRepository.AddUser(userTosave));
}
return(null);
}
public async Task <UserDto> CreateSession(UserToLoginDto userToLogin)
{
User user = await _context.Users.FirstOrDefaultAsync(x => x.Email == userToLogin.Email);
if (user == null)
{
return(null);
}
else if (!VerifyPasswordHash(userToLogin.Password, user.PswHash, user.PswSalt))
{
return(null);
}
return(ConvertToUserDto(user));
}
public async Task <IActionResult> Login(UserToLoginDto userToLogin)
{
//Pull user from db
var dbUser = await this.authRepository.Login(userToLogin.Username.ToLower(), userToLogin.Password);
Console.WriteLine();
//Check if user exists
if (dbUser == null)
{
return(Unauthorized());
}
var userContext = this.mapper.Map <UserContextDTO>(dbUser);
userContext.Token = GenerateAuthToken(dbUser);
//Write token into response sent to client
return(Ok(userContext));
}
public async Task <IActionResult> Login(UserToLoginDto userToLoginDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ResponseMessage.Message("Fill out all the files", ModelState)));
}
var checkUser = await _userRepository.GetUserByEmail(userToLoginDto.Email);
if (checkUser == null)
{
return(BadRequest(ResponseMessage.Message("User does not exist")));
}
var token = await _userRepository.LoginUser(userToLoginDto);
return(Ok(ResponseMessage.Message("You account has been logged-in", null, token)));
}
public async Task <IActionResult> Login(UserToLoginDto model)
{
var user = await _authService.Login(model.Username, model.Password);
try
{
var key = Encoding.ASCII.GetBytes(_configuration.GetSection("AppSettings:Token").Value);
UserDto userDto = _mapper.Map <UserDto>(user);
userDto.Token = HelperMethods.CreateJWT(key, userDto);
return(Ok(userDto));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> Login(UserToLoginDto userToLogin)
{
var userInRepository = await _repository.Login(userToLogin.Username, userToLogin.Password);
if (userInRepository == null)
{
return(Unauthorized());
}
var token = _signing.GenerateToken(new string[] {
userInRepository.Id.ToString(),
userInRepository.Username,
});
return(Ok(new
{
token = token
}));
}
public async Task <IActionResult> Login(UserToLoginDto user)
{
var userToLogin = await _userManager.FindByNameAsync(user.UserName);
var result = await _signInManager.CheckPasswordSignInAsync(userToLogin, user.Password, false);
if (result.Succeeded)
{
var appUser = await _userManager.Users.FirstOrDefaultAsync(user => user.NormalizedUserName == userToLogin.UserName.ToUpper());
var userToReturn = _mapper.Map <UserToReturn>(appUser);
return(Ok(new {
token = GenerateToken(appUser).Result,
user = userToReturn
}));
}
return(Unauthorized());
}
public async Task <IActionResult> LoginAsync(UserToLoginDto userToLogin)
{
if (ModelState.IsValid)
{
IServiceResult <string> loginResult = await _authService.LoginAsync(userToLogin);
if (loginResult.Result == ResultType.Correct)
{
return(Ok(new { username = userToLogin.Username, token = loginResult.ReturnedObject }));
}
else
{
return(Unauthorized(loginResult.Errors));
}
}
else
{
return(BadRequest(ModelState.Values));
}
}
public async Task <IActionResult> Login([FromBody] UserToLoginDto userToLoginDto)
{
// Check if user exists
var user = await _userManager.FindByNameAsync(userToLoginDto.Username);
var result = await _signInManager.CheckPasswordSignInAsync(user, userToLoginDto.Password, false);
if (result.Succeeded)
{
var appuser = _mapper.Map <UserForListDto>(user);
return(Ok(new
{
token = GenerateJwtToken(user).Result,
user = appuser
}));
}
return(Unauthorized());
}
public async Task <IActionResult> Login([FromBody] UserToLoginDto user)
{
try
{
var userToLogin = await _userService.Login(user.Username, user.Password);
if (userToLogin == null)
{
return(BadRequest("Username or Password is wrong"));
}
_log.LogInformation($"Returning token {userToLogin.Token} for user with id {userToLogin.Id}");
return(Ok(userToLogin));
}
catch (Exception ex)
{
_log.LogError($"Something went wrong: {ex}");
return(StatusCode(500, ex));
}
}
public IActionResult Login([FromBody] UserToLoginDto user)
{
if (user == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var UserFromClient = Mapper.Map <Entities.User>(user);
if (_messangerRepository.UserWithUsernameAndPasswordExist(UserFromClient))
{
var usertoreturnenumerable = _messangerRepository.GetLoggedUser(UserFromClient);
var UserToReturn = Mapper.Map <Models.LoggedUserToReturnDto>(usertoreturnenumerable);
return(Ok(UserToReturn));
}
return(BadRequest());
}
public async Task <IActionResult> Login(UserToLoginDto userToLoginDto)
{
// check in DB if user exists
var userFromRepo = await _repo.Login(userToLoginDto.Username.ToLower(), userToLoginDto.Password); // I am storing usernames in DB lowercased
if (userFromRepo == null)
{
return(Unauthorized());
}
var claims = new[]
{
// my token gonna take two claims -> user's ID and user's username
new Claim(ClaimTypes.NameIdentifier, userFromRepo.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.Username)
};
// use the token from appsettings in bytes
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config.GetSection("AppSettings:Token").Value));
// hash the token
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();
// create a jwt
var token = tokenHandler.CreateToken(tokenDescriptor);
// write the token into the response of login
return(Ok(new
{
token = tokenHandler.WriteToken(token)
}));
}
public async Task <IActionResult> Login(UserToLoginDto userToLoginDto)
{
var user = await _auth.Login(userToLoginDto.UserName.ToLower(), userToLoginDto.Password);
if (user == null)
{
return(Unauthorized());
}
// Defining the payload of token(can be seen by anyone so don't put sensitive content)
var claims = new[]
{
new Claim(System.Security.Claims.ClaimTypes.NameIdentifier, user.Id.ToString()),
new Claim(System.Security.Claims.ClaimTypes.Name, user.Name)
};
// using the secret key
var key = new SymmetricSecurityKey(Encoding.ASCII
.GetBytes(_config.GetSection("AppSettings:Token").Value));
// encrypting the key using HMACSHA512Signature ALgorithm
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
// Creating token descriptor containing the claims, creds and expiry date
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds
};
// Creating token handler to create token
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(new{
token = tokenHandler.WriteToken(token)
}));
}
public async Task <IActionResult> GetActionResultAsync(UserToLoginDto model)
{
if (ModelState.IsValid)
{
var result = await _userManager.FindByEmailAsync(model.Email);
if (result != null)
{
var dto = new UserToReturnDto
{
FirstName = result.FirstName,
LastName = result.LastName,
Gender = result.Gender,
Email = result.Email,
DateCreated = result.DateCreated
};
return(Ok(dto));
}
}
return(BadRequest("Incorrect User Input"));
}
public async Task <IActionResult> SignIn([FromBody] UserToLoginDto 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(new
{
token = GenerateJwt(user),
user = _mapper.Map <UserAuthDto>(user)
}));
}
return(BadRequest("Email or password incorrect."));
}
