public ActionResult CreateToken(User user)
{
System.Console.WriteLine(user.Username + " " + user._id + " " + user.Type);
var token = _tokenBuilder.BuildToken(user._id, user.Username, user.Type);
return(Ok(token));
}
public UserWithToken Authenticate(string username, string password)
{
var usr = _uow.Query <User>()
.Where(x => x.Username == username && !x.IsDeleted)
.Include(x => x.Roles)
.ThenInclude(x => x.Role)
.FirstOrDefault();
if (usr == null)
{
throw new BadRequestException("incorrect username or password");
}
if (string.IsNullOrWhiteSpace(password) || !usr.Password.VerifyWithBCrypt(password))
{
throw new BadRequestException("incorrect username or password");
}
var expiresIn = DateTime.Now + TokenAuthOption.ExpiresSpan;
var token = _tokenBuilder.BuildToken(usr.Username, usr.Roles.Select(x => x.Role.Name).ToArray(), expiresIn);
return(new UserWithToken
{
ExpiresAt = expiresIn,
Token = token,
User = usr
});
}
public async Task <IActionResult> Login([FromBody] User user)
{
try
{
var dbUser = await _userBusinessLogic.GetUserAsync(user.Username);
if (dbUser == null)
{
return(NotFound("User not found."));
}
var isValid = BCrypt.Net.BCrypt.Verify(user.Password, dbUser.Password);
if (!isValid)
{
return(BadRequest("Could not authenticate user."));
}
var token = _tokenBuilder.BuildToken(user.Username);
return(Ok(token));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message + " " + ex.StackTrace));
}
}
public async Task <IActionResult> Login(LoginViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
// Attempt to Login
var user = await userRepo.LoginUserAsync(viewModel.Email, viewModel.Password);
// Disallow logging in if the email has not been
// confirmed by the User yet
if (!user.EmailConfirmed)
{
return(Unauthorized("Email must be confirmed before proceeding."));
}
logger?.LogInformation($"User JWT accessed: {user.Email}");
return(Ok(tokenBuilder.BuildToken(user.Email)));
}
// BadRequest if User does not exist
catch (UserDoesNotExistException)
{
return(BadRequest($"The User with email {viewModel.Email} does not exist"));
}
// Bad request if password does not match hashed password
catch (UserPasswordDoesNotMatchException)
{
return(BadRequest($"The password did not match"));
}
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> SignUp([FromBody] UserSignUpVM user)
{
ApplicationUser appUser = _mapper.Map <UserSignUpVM, ApplicationUser>(user);
appUser.UserName = user.Email;
IdentityResult result = await _userManager.CreateAsync(appUser, user.Password);
if (result == IdentityResult.Success)
{
await _signInManager.SignInAsync(appUser, false);
var token = _tokenBuilder.BuildToken(appUser);
return(Ok(token));
}
else
{
return(BadRequest("User already exists"));
}
}
public async Task <IActionResult> Login([FromBody] User user)
{
var dbUser = await _context.Users.FirstOrDefaultAsync(u => u.Username == user.Username);
if (dbUser != null)
{
// Пароль для упрощения храниться в чистом виде!
// В реальных проектах, необходимо хранить пароль в виде хэша с солью.
if (dbUser.Password == user.Password)
{
var token = _tokenBuilder.BuildToken(user.Username);
return(Ok(token));
}
return(BadRequest("Could not authenticate user."));
}
return(NotFound("User not found."));
}
public async Task <IActionResult> Login(UserForLoginDto userForLoginDto)
{
var userFromRepo = await _repo.Login(userForLoginDto.Username.ToLower(), userForLoginDto.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
var tokenObj = _tokenBuilder.BuildToken(userFromRepo);
return(Ok(tokenObj));
}
private TokenResponse GetTokenResponse(ApplicationCore.Entities.Admin user, bool isPersistent)
{
var expiresAtUtc = DateTime.UtcNow.AddDays(7);
var token = _tokenBuilder.BuildToken(user, expiresAtUtc, isPersistent);
_logger.Info($"{user.Username} requested new token.");
return(new TokenResponse
{
AccessToken = token,
ExpiresAtUtc = expiresAtUtc
});
}
public async Task <ActionResult> SignUp([Bind("Email,Password")] UserSignUpVM userVM)
{
if (ModelState.IsValid)
{
try
{
var user = new ApplicationUser
{
Id = Guid.NewGuid().ToString(),
Email = userVM.Email,
Password = _passwordService.HashPassword(userVM.Password)
};
await _cosmosDbService.AddUserAsync(user);
var token = _tokenBuilder.BuildToken(user);
return(Ok(token));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
return(BadRequest("Invalid user model"));
}
public Task <string> Handle(GenerateUserTokenCommand request, CancellationToken cancellationToken)
{
return(Task.Run(() =>
{
if (string.IsNullOrEmpty(request.UserName) || string.IsNullOrEmpty(request.Password))
{
return null;
}
var user = _repository.GetUser(request.UserName);
return user == null || _cryptPassword.GetCrypted(request.Password) != user.Password
? null
: _tokenBuilder.BuildToken(user);
}));
}
public ActionResult <String> PostUser1(Users user)
{
var dateCurrent = DateTime.Now;
// Console.WriteLine(user.username);
// Console.WriteLine(user.password);
var result = (from u in _context.Users
// join s in _context.Shops on u.id equals s.id
where u.isDeleted == false &&
u.username == user.username &&
u.password == user.password &&
u.ShopsId == user.ShopsId &&
u.Shops.time_open <= dateCurrent &&
dateCurrent <= u.Shops.time_close
select new
{
u.id,
u.name,
u.username,
u.PositionsId,
u.ShopsId
}).FirstOrDefault();
// Console.WriteLine(result);
if (result == null)
{
return(NotFound());
}
else
{
var userData = _context.Users.Find(result.id);
var token = _tokenBuilder.BuildToken(userData);
userData.remember_token = token;
_context.Update(userData);
_context.SaveChangesAsync();
var us = new Users();
us.username = user.username;
us.ShopsId = user.ShopsId;
us.PositionsId = userData.PositionsId;
us.remember_token = token;
HttpContext.Session.SetObjectAsJson("user", us);
return(token);
//return CreatedAtAction("GetUser", "abc");
}
}
public async Task <IActionResult> Login([FromBody] LoginBindingModel model)
{
var user = await _userRepository.FindAsync(x => x.Email == model.Email);
if (user == null)
{
return(NotFound("User not found."));
}
var(Verified, NeedsUpgrade) = _passwordHasher.Check(user.Password, model.Password);
if (!Verified)
{
return(BadRequest("Could not authenticate user."));
}
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, user.Username),
new Claim(ClaimTypes.Role, user.Role),
};
var authProperties = new AuthenticationProperties
{
IsPersistent = model.RememberMe,
ExpiresUtc = DateTimeOffset.UtcNow.AddHours(1)
};
var claimsIdentity = new ClaimsIdentity(
claims,
CookieAuthenticationDefaults.AuthenticationScheme);
await HttpContext.SignInAsync(
CookieAuthenticationDefaults.AuthenticationScheme,
new ClaimsPrincipal(claimsIdentity),
authProperties);
var token = _tokenBuilder.BuildToken(user.Username);
return(Ok(token));
}
public async Task <IActionResult> Login([FromBody] User user)
{
var userResult = _userService.Authenticate(user.Username, user.Password);
if (userResult == null)
{
return(BadRequest("Username or password is incorrect"));
}
var token = await _tokenBuilder.BuildToken(userResult);
return(Ok(new
{
UserId = userResult.UserId,
Username = userResult.Username,
FirstName = userResult.FirstName,
LastName = userResult.LastName,
Role = userResult.Role,
Token = token
}));
}
public async Task <string> Login(User user)
{
var dbUser = (await _userRepository.GetAllAsync())
.SingleOrDefault(u => u.Username == user.Username);
if (dbUser == null)
{
return(string.Empty);
}
CryptoHelper cryptoHelper = new CryptoHelper();
var isValid = cryptoHelper.Decrypt(dbUser.Password) == user.Password;
if (!isValid)
{
return(string.Empty);
}
var token = _tokenBuilder.BuildToken(user.Username);
return(token);
}
public async Task <IActionResult> Login([FromBody] User user)
{
var dbUser = await _context
.Users
.SingleOrDefaultAsync(u => u.UserName == user.UserName);
if (dbUser == null)
{
return(NotFound("User not found."));
}
var isValid = dbUser.Password == user.Password;
if (!isValid)
{
return(BadRequest("Could not authenticate user."));
}
var token = _tokenBuilder.BuildToken(user.UserName);
return(Ok(token));
}
public async Task <IActionResult> Login([FromBody] UserDto user)
{
var dbUser = await _context
.Users
.SingleOrDefaultAsync(u => u.Username == user.Username);
if (dbUser == null)
{
return(NotFound("User not found."));
}
// This is just an example, made for simplicity; do not store plain passwords in the database
// Always hash and salt your passwords
var isValid = dbUser.Password == user.Password;
if (!isValid)
{
return(BadRequest("Could not authenticate user."));
}
var token = _tokenBuilder.BuildToken(user.Username);
return(Ok(token));
}
public IActionResult LoginForm([FromBody] Users users)
{
if (ModelState.IsValid)
{
if (!_context.Users.Any(u => u.username == users.username && u.password == users.password && u.ShopsId == users.ShopsId))
{
return(Content("Tài khoản hoặc mật khẩu không đúng !"));
}
else
{
var result = _loginRepository.GetUser(users);
if (result != null)
{
var userData = _context.Users.Find(result.id);
var remember_token = _tokenBuilder.BuildToken(userData);
userData.remember_token = remember_token;
_context.Update(userData);
_context.SaveChangesAsync();
var us = new Users();
us.id = userData.id;
us.username = userData.username;
us.ShopsId = userData.ShopsId;
us.PositionsId = userData.PositionsId;
us.remember_token = remember_token;
HttpContext.Session.SetObjectAsJson("user", us);
return(CreatedAtAction("GetUser", remember_token));
}
return(StatusCode(202, "Tài khoản hết hạn !"));
//var dateNow = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd"));
//var result = from u in _context.Users
// where u.username == users.username &&
// u.password == users.password &&
// u.ShopsId == users.ShopsId &&
// u.Shops.time_open <= dateNow &&
// u.Shops.time_close >= dateNow &&
// u.isDeleted == false
// select new
// {
// u.id,
// u.name,
// u.username,
// u.PositionsId,
// u.ShopsId
// };
//if (result.Count() > 0)
//{
// var userData = _context.Users.Find(result.First().id);
// var remember_token = _tokenBuilder.BuildToken(userData);
// userData.remember_token = remember_token;
// _context.Update(userData);
// _context.SaveChangesAsync();
// var us = new Users();
// us.id = userData.id;
// us.username = userData.username;
// us.ShopsId = userData.ShopsId;
// us.PositionsId = userData.PositionsId;
// us.remember_token = remember_token;
// HttpContext.Session.SetObjectAsJson("user", us);
// return CreatedAtAction("GetUser", remember_token);
//}
//else
// return StatusCode(202, "Tài khoản hết hạn !");
}
}
else
{
return(Content("Vui lòng kiểm tra lại thông tin"));
}
}