public UserWithToken Authenticate(string email, string password)
{
var user = (from u in _unitOfWork.Query <UserEntity>()
where u.Email == email
select u)
.Include(r => r.Roles)
.ThenInclude(r => r.Role)
.FirstOrDefault();
if (user == null)
{
throw new BadRequestException("email/password not valid!");
}
if (string.IsNullOrEmpty(password) || !user.Password.VerifyWithBCrypt(password))
{
throw new BadRequestException("email/password not valid!");
}
var expiryPeriod = DateTime.Now.ToLocalTime() + TokenAuthOption.ExpiresSpan;
var token = _tokenBuilder.Build(user.Email, user.Roles.Select(r => r.Role.RoleName).ToArray(), expiryPeriod);
return(new UserWithToken
{
ExpiresAt = expiryPeriod,
Token = token,
User = user
});
}
public UserWithToken Authenticate(string username, string password)
{
var user = (from u in _uow.Query <User>()
where u.UserName == username && !u.IsDeleted
select u)
.Include(x => x.Roles)
.ThenInclude(x => x.Role)
.FirstOrDefault();
if (user == null)
{
throw new BadRequestException("username/password aren't right");
}
if (string.IsNullOrWhiteSpace(password) || !user.Password.VerifyWithBCrypt(password))
{
throw new BadRequestException("username/password aren't right");
}
var expiresIn = DateTime.Now + TokenAuthOption.ExpiresSpan;
var token = _tokenBuilder.Build(user.UserName, user.Roles.Select(x => x.Role.Name).ToArray(), expiresIn);
return(new UserWithToken
{
ExpiresAt = expiresIn,
Token = token,
User = user
});
}
public async Task <Response> Handle(Request request, CancellationToken cancellationToken)
{
var user = await _context.Users
.Include(x => x.Roles)
.SingleOrDefaultAsync(x => x.Username == request.Username);
if (user == null)
{
throw new Exception();
}
if (!ValidateUser(user, _passwordHasher.HashPassword(user.Salt, request.Password)))
{
throw new Exception();
}
_tokenBuilder
.AddUsername(user.Username)
.AddOrUpdateClaim(new System.Security.Claims.Claim(Constants.ClaimTypes.UserId, $"{user.UserId}"));
foreach (var role in user.Roles)
{
_tokenBuilder.AddOrUpdateClaim(new System.Security.Claims.Claim(Constants.ClaimTypes.Role, role.Name));
}
return(new(_tokenBuilder.Build(), user.UserId));
}
public Task <CommandResult> Handle(LoginCommand input)
{
var user = userRepo.Get(input.Email);
if (user == null || user.Credentials == null)
{
return(CommandResult.Fail(UserManagementError.InvalidEmailOrPassword()).AsTask());
}
if (user.Credentials.EmailVerified == null)
{
return(CommandResult.Fail(UserManagementError.EmailNotVerified()).AsTask());
}
if (!hasher.VerifyPassword(user.Credentials.Password, input.Password))
{
return(CommandResult.Fail(UserManagementError.InvalidEmailOrPassword()).AsTask());
}
var tokenDto = new TokenDto()
{
Token = tokenBuilder.Build(user, appSettings.TokenDurationMinutes),
TokenDurationMinutes = appSettings.TokenDurationMinutes,
Domain = appSettings.TokenDomain
};
return(CommandResult <TokenDto> .Success(tokenDto).AsTask());
}
public async Task <TokenModel> Login(CredentialModel credential)
{
try
{
return(await _tokenBuilder.Build(credential));
}
catch (FaultException ex)
{
throw new FaultException(ex.Message);
}
catch (Exception ex)
{
Logger.Error("Error in Login method", ex);
throw new FaultException("An error occurred, please try again later.");
}
}
public async Task <Token> Issue(TokenIssueRequest request)
{
var user = await FindValideUserAsync(request);
if (user != null)
{
var roles = await _userManager.GetRolesAsync(user);
var token = _tokenBuilder.Build(user, roles);
await UpsertRefreshTokenAsync(token);
return(token);
}
return(null);
}
public UserWithToken Login(string userName, string Password)
{
var user = _unitOfWork.GetRepository <Applications>().FirstOrDefault(x => x.UserName == userName, x => x.Scopes);
if (user == null)
{
throw new UnauthorizedAccessException("username/password aren't right");
}
var expiresIn = DateTime.Now.AddMinutes(30);
var token = _tokenBuilder.Build(user.Name, user.Scopes.Select(x => x.ScopeName).ToArray(), expiresIn);
return(new UserWithToken
{
ExpiresAt = expiresIn,
Token = token
});
}
public async Task <TokenDto> Login(LoginDto loginDto)
{
try
{
var user = await _userRepository.FindByUserName(loginDto.Login);
if (user is null)
{
throw new InvalidLoginAttemptException("User with given credentials doesn't exists");
}
var passwordVerificationResult = _passwordHasher.VerifyHashedPassword(user, user.Password, loginDto.Password);
if (passwordVerificationResult != PasswordVerificationResult.Success)
{
throw new UnauthorizedAccessException("Invalid credentials");
}
var roles = await _roleRepository.GetUserRoles(loginDto.Login);
var permissions = await _roleRepository.GetUserPermissions(loginDto.Login);
var(token, validTo) = _tokenBuilder.Build(user, GetUserClaims(user, roles, permissions));
user.SignIn();
await _userRepository.Update(user);
await _userRepository.UnitOfWork.Commit();
return(new TokenDto
{
UserId = user.Id,
Token = token,
ValidTo = validTo,
IssuedAt = DateTime.UtcNow
});
}
catch (Exception)
{
await _userRepository.UnitOfWork.Rollback();
throw;
}
}
public async Task <Response> Handle(Request request, CancellationToken cancellationToken)
{
var user = await _context.Users.SingleOrDefaultAsync(x => x.Username == request.Username);
if (user == null)
{
throw new Exception();
}
if (!ValidateUser(user, _passwordHasher.HashPassword(user.Salt, request.Password)))
{
throw new Exception();
}
_tokenBuilder
.AddUsername(user.Username);
return(new(_tokenBuilder.Build(), user.UserId));
}
public async Task <ITokenInfo> GetTokenInfoAsync(UrlToken urlToken, bool skipValidation = false)
{
const string InvalidTokenMessage = "Autorization token is invalid";
try
{
if (urlToken is ValidUrlToken validUrlToken)
{
return(skipValidation
? _noValidationBuilder.Build(validUrlToken.RawToken)
: await _validationBuilder.ValidateAndBuildAsync(validUrlToken.RawToken));
}
throw new ApplicationException(InvalidTokenMessage);
}
catch (Exception ex)
{
throw new ApplicationException(InvalidTokenMessage, ex);
}
}
public async Task <Response> Handle(Request request, CancellationToken cancellationToken)
{
var userAccountRoles = await(from u in _context.Users
join a in _context.Accounts on u.UserId equals a.UserId
join rr in _context.Users.SelectMany(x => x.Roles) on true equals true
join r in _context.Roles on rr.RoleId equals r.RoleId
where u.Username == request.Username
select new
{
User = u,
Role = r,
Account = a
}).ToListAsync();
var user = userAccountRoles.FirstOrDefault().User;
var account = userAccountRoles.First().Account;
if (user == null)
{
throw new Exception();
}
if (!ValidateUser(user, _passwordHasher.HashPassword(user.Salt, request.Password)))
{
throw new Exception();
}
foreach (var role in userAccountRoles.Select(x => x.Role))
{
_tokenBuilder.AddOrUpdateClaim(new Claim(Constants.ClaimTypes.Role, role.Name));
}
_tokenBuilder
.AddUsername(user.Username)
.AddOrUpdateClaim(new Claim(Constants.ClaimTypes.AccountId, $"{account.AccountId}"))
.AddOrUpdateClaim(new Claim(Constants.ClaimTypes.UserId, $"{account.UserId}"));
return(new(_tokenBuilder.Build(), user.UserId));
}
public async Task <string> LoginAsync(AccountEntity parameters)
{
var account = await _dkmsRepository.FirstAsync <AccountEntity>(s => s.Phone == parameters.Phone);
if (account == null)
{
throw new DkmsException("用户名或密码错误");
}
if (!_passwordFactory.VerifyPassword(account, parameters.Password))
{
throw new DkmsException("用户名或密码错误");
}
var tokenString = _tokenBuilder.Build();
var token = new TokenEntity
{
Token = tokenString,
UserId = account.Id
};
await _dkmsRepository.AddAsync(token);
return(tokenString);
}
public UserToken Authenticate(string username, string password)
{
var user = _db.Query <Users>().FirstOrDefault(w => w.Username == username);
if (user is null)
{
throw new BadRequestException("username/password aren't right");
}
if (string.IsNullOrWhiteSpace(password) || !user.Password.VerifyCrypt(password))
{
throw new BadRequestException("username/password aren't right");
}
var expiresIn = DateTime.Now + TokenAuthOption.ExpiresSpan;
var token = _tokenBuilder.Build(user.Username, Roles.GetRoles().ToArray(), expiresIn);
return(new UserToken
{
ExpiresAt = expiresIn,
Token = token,
User = user
});
}
static void Main(string[] args)
{
string expr = "1+a*3";
Dictionary <string, double> variables = new();
List <ITokenAcceptor <IToken> > constantAcceptors = new();
constantAcceptors.Add(new ConstantToken.Acceptor());
constantAcceptors.Add(new VariableToken.Acceptor());
List <ITokenAcceptor <IToken> > binaryAcceptors = new();
binaryAcceptors.Add(new AddToken.Acceptor());
binaryAcceptors.Add(new SubtractToken.Acceptor());
binaryAcceptors.Add(new MultiplyToken.Acceptor());
int index = 0;
ITokenBuilder <IToken>? root = null;
IBinaryTokenBuilder <IBinaryToken>?lastBinary = null;
ITokenBuilder <IToken>? _left = null;
List <ITokenAcceptor <IToken> > acceptors = constantAcceptors;
while (index < expr.Length)
{
bool foundAcceptor = false;
foreach (ITokenAcceptor <IToken> acceptor in acceptors)
{
ITokenBuilder <IToken>?builder = acceptor.Accept(expr, ref index);
if (builder != null)
{
IBinaryTokenBuilder <IBinaryToken>?builderAsBinary = builder as IBinaryTokenBuilder <IBinaryToken>;
if (root == null)
{
if (builderAsBinary != null)
{
throw new Exception("First token cannot be a binary token");
}
root = builder;
}
if (builderAsBinary != null)
{
if (lastBinary == null || lastBinary.IsMultiply || !builderAsBinary.IsMultiply)
{
if (lastBinary != null)
{
lastBinary.Right = _left;
}
builderAsBinary.Left = root;
root = builder;
}
else
{
builderAsBinary.Left = _left;
lastBinary.Right = builder;
}
lastBinary = builderAsBinary;
_left = null;
acceptors = constantAcceptors;
}
else
{
_left = builder;
acceptors = binaryAcceptors;
if (builder is VariableToken variableToken)
{
variables[variableToken.Name] = 0;
}
}
foundAcceptor = true;
break;
}
}
if (!foundAcceptor)
{
Console.WriteLine($"Cannot determine token '{expr[index]}'");
Console.WriteLine(expr);
Console.WriteLine($"{new string(' ', index)}^{new string('-', expr.Length - index + 2)}");
root = null;
break;
}
}
if (_left != null && lastBinary != null)
{
lastBinary.Right = _left;
}
if (root != null)
{
foreach (string key in variables.Keys)
{
Console.WriteLine($"Define the value for {key}:");
while (true)
{
string answer = Console.ReadLine() ?? "";
if (double.TryParse(answer, out double result))
{
variables[key] = result;
break;
}
else
{
Console.WriteLine("Not a double!");
}
}
}
IToken rootToken = root.Build();
PrintToken(rootToken, 0, variables);
Console.WriteLine($"Calculated: {expr} = {rootToken.Calculate(variables)}");
}
else
{
Console.WriteLine("No token defined!");
}
}