public async Task <AuthenticationResultModel> Authenticate(UserModel model)
{
var result = new AuthenticationResultModel();
var hash = model.Password;
var user = await _context.Users.FirstOrDefaultAsync(_ => _.Username == model.Username &&
_.Password == hash);
if (user == null)
{
result.Success = false;
result.Error = new ErrorModel
{
Code = 1002,
ErrorMessage = "Incorrect login or password"
};
}
else
{
result.User = _mapper.Map <UserModel>(user);
result.Success = true;
}
return(result);
}
public async Task <IActionResult> Post([FromBody] AuthenticationModel model)
{
User user = await _userManager.FindByEmailAsync(model.Email);
if (user is null || !await _userManager.CheckPasswordAsync(user, model.Password))
{
throw new ApiException("The email or password is incorrect.", StatusCodes.Status401Unauthorized);
}
var claims = new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, user.Id)
};
var token = new JwtSecurityToken(
issuer: AuthOptions.ISSUER,
audience: AuthOptions.AUDIENCE,
claims: claims,
expires: DateTime.Now.AddMinutes(AuthOptions.LIFETIME),
signingCredentials: new SigningCredentials(
AuthOptions.GetSymmetricSecurityKey(),
SecurityAlgorithms.HmacSha256)
);
string encodedJwt = new JwtSecurityTokenHandler().WriteToken(token);
var result = new AuthenticationResultModel
{
AccessToken = encodedJwt,
DisplayName = user.DisplayName,
ExpirationTime = AuthOptions.LIFETIME
};
return(Ok(result));
}
public async Task <AuthenticationResultModel> GenerateJwtByRefreshToken(string token)
{
var user = _context.Users.SingleOrDefault(u => u.RefreshTokens.Any(t => t.Token == token));
if (user == null)
{
return(AuthenticationResultModel.Failed($"Token did not match any users."));
}
var refreshToken = user.RefreshTokens.Single(x => x.Token == token);
if (!refreshToken.IsActive)
{
return(AuthenticationResultModel.Failed($"Token Not Active."));
}
//Revoke Current Refresh Token
refreshToken.Revoked = DateTime.UtcNow;
//Generate new Refresh Token and save to Database
var newRefreshToken = RefreshTokenGenerator.CreateRefreshToken();
user.RefreshTokens.Add(newRefreshToken);
_context.Update(user);
_context.SaveChanges();
return(await GetAuthenticationResultModel(user, newRefreshToken));
}
public async Task <AuthenticationResultModel> GenerateJwtByUserPass(AuthenticationRequestModel model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(AuthenticationResultModel.Failed($"No Accounts Registered with {model.Email}."));
}
if (await _userManager.CheckPasswordAsync(user, model.Password))
{
var refreshToken = new RefreshToken();
if (user.RefreshTokens.Any(a => a.IsActive))
{
refreshToken = user.RefreshTokens.FirstOrDefault(a => a.IsActive);
}
else
{
refreshToken = RefreshTokenGenerator.CreateRefreshToken();
user.RefreshTokens.Add(refreshToken);
_context.Update(user);
_context.SaveChanges();
}
return(await GetAuthenticationResultModel(user, refreshToken));
}
return(AuthenticationResultModel.Failed("Incorrect Credentials for user {user.Email}."));
}
public async Task <AuthenticationResultModel> AuthenticateAsync(UsersMaster user)
{
// authentication successful so generate jwt token
AuthenticationResultModel authenticationResult = new AuthenticationResultModel();
var tokenHandler = new JwtSecurityTokenHandler();
try
{
var key = Encoding.ASCII.GetBytes(_appSettings.JwtSettings.Secret);
ClaimsIdentity Subject = new ClaimsIdentity(new Claim[]
{
new Claim("UserId", user.UserId.ToString()),
new Claim("FirstName", user.FirstName),
new Claim("LastName", user.LastName),
new Claim("EmailId", user.Email == null?"":user.Email),
new Claim("UserName", user.UserName == null?"":user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
});
foreach (var item in GetUserRole(user.UserId))
{
Subject.AddClaim(new Claim(ClaimTypes.Role, item.RoleName));
}
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = Subject,
Expires = DateTime.UtcNow.Add(_appSettings.JwtSettings.TokenLifetime),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
authenticationResult.Token = tokenHandler.WriteToken(token);
var refreshToken = new RefreshToken
{
Token = Guid.NewGuid().ToString(),
JwtId = token.Id,
UserId = user.UserId,
CreationDate = DateTime.UtcNow,
ExpiryDate = DateTime.UtcNow.AddMonths(6)
};
await _context.RefreshTokens.AddAsync(refreshToken);
await _context.SaveChangesAsync();
authenticationResult.RefreshToken = refreshToken.Token;
authenticationResult.Success = true;
return(authenticationResult);
}
catch (Exception ex)
{
return(null);
}
}
public AuthenticationResultModel Authenticate(AuthenticationInputModel input)
{
var outputModel = new AuthenticationResultModel {
Input = input
};
var operation = _authentications.FirstOrDefault(a => a.Metadata.AuthenticationType == input.TypeString);
outputModel.Result = operation == null ? "Implementation cannot be found" : operation.Value.Authenticate(input.Username, input.Password);
return(outputModel);
}
internal ManagementSession(ManagementService service, string username, AuthenticationResultModel authentication)
{
this.service = service;
this.Token = authentication.AccessToken;
var accessToken = authentication.AccessToken;
CurrentUserId = authentication.UserId;
this.refreshToken = authentication.RefreshToken;
this.CurrentUserName = username;
Initialize(accessToken, new DateTimeOffset(authentication.ExpireDate));
}
#pragma warning restore CS0067
private async void ChangeControlsState(bool isEntered, AuthenticationResultModel result)
{
_loginViewModel.ResultOfLoginTry = string.Empty;
await Task.Delay(100);
if (isEntered)
{
_loginViewModel.ForegroundColor = Brushes.Green;
_loginViewModel.ResultOfLoginTry = $"Welcome again, {result.User.Nickname}!";
}
else
{
_loginViewModel.ClearPassword();
_loginViewModel.ResultOfLoginTry = result.Error.ErrorMessage;
}
}
public async Task <AuthenticationResultModel> Register(RegistrationModel registration)
{
//Check if username already exists.
var existingUser = _userService.GetAll(u => u.Username == registration.Username).FirstOrDefault();
if (existingUser != null)
{
throw new ExceptionUsernameAlreadyExists();
}
var passwordHash = PasswordHelper.HashPassword(registration.Password);
var userToCreate = new User
{
FirstName = registration.FirstName.ToLower(),
LastName = registration.LastName.ToLower(),
Email = registration.Email.ToLower(),
Username = registration.Username.ToLower(),
PasswordHash = passwordHash
};
//userToCreate.UserRole.Add(new UserRole
//{
// RoleId = (long)Roles.BasicUser
//});
await _userService.Create(userToCreate);
var createdUser = _userService.GetAllThenInclude(
u => u.Id == userToCreate.Id,
IncludeBuilder <User> .Include(u => u.UserRole).ThenInclude(ur => ur.Role).Done()
).Single();
//Registration successful so generate jwt token
var token = GenerateToken(createdUser);
var authenticationResultModel = new AuthenticationResultModel
{
UserId = createdUser.Id,
Token = token
};
return(authenticationResultModel);
}
public AuthenticationResultModel Authenticate(User loginCredentials)
{
var user = FindUser(loginCredentials);
if (user == null)
{
throw new UserNotFound();
}
var tokenString = GenerateJwtToken(user);
var result = new AuthenticationResultModel
{
User = user,
TokenString = tokenString
};
return(result);
}
private async Task <AuthenticationResultModel> GetAuthenticationResultModel(ApplicationUser user,
RefreshToken refreshToken)
{
//Generates new jwt
var authenticationModel = new AuthenticationResultModel();
authenticationModel.IsAuthenticated = true;
JwtSecurityToken jwtSecurityToken = await _tokenGenerator.CreateJwtToken(user);
authenticationModel.Token = new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken);
authenticationModel.Email = user.Email;
authenticationModel.UserName = user.UserName;
var rolesList = await _userManager
.GetRolesAsync(user).ConfigureAwait(false);
authenticationModel.Roles = rolesList.ToList();
authenticationModel.RefreshToken = refreshToken;
return(authenticationModel);
}
public AuthenticationResultModel CreateUser(UserModel i_Model)
{
AuthenticationResultModel registerResult = new AuthenticationResultModel
{
Error = eErrors.None,
HasError = false,
UserRole = eUserRole.RegularUser
};
if (CheckUserRegistrationValidation(i_Model))
{
using (MyDiveEntities MyDiveDB = new MyDiveEntities())
{
int userID = MyDiveDB.stp_CreateUser(
i_Model.Username,
i_Model.Password,
i_Model.Email,
i_Model.FirstName,
i_Model.LastName,
i_Model.Association,
i_Model.UserLicenseNumber,
i_Model.LicenseTypeID,
i_Model.Birthday,
(int)eUserRole.RegularUser,
i_Model.ProfilePicture.Picture,
(int)ePictureType.ProfilePicture);
registerResult.UserID = userID;
}
}
else
{
Logger.Instance.Notify("user info in insufficient", eLogType.Error, JsonConvert.SerializeObject(i_Model));
registerResult.Error = eErrors.InsufficientData;
registerResult.HasError = true;
}
return(registerResult);
}
public async Task <ResponseModel <TokenModel> > LoginAsync(LoginModel login)
{
ResponseModel <TokenModel> response = new ResponseModel <TokenModel>();
try
{
UsersMaster loginUser = _context.UsersMasters.FirstOrDefault(c => c.UserName == login.UserName && c.Password == login.Password);
if (loginUser == null)
{
response.IsSuccess = false;
response.Message = "Invalid Username And Password";
return(response);
}
AuthenticationResultModel authenticationResult = await AuthenticateAsync(loginUser);
if (authenticationResult != null && authenticationResult.Success)
{
response.Data = new TokenModel()
{
Token = authenticationResult.Token, RefreshToken = authenticationResult.RefreshToken
};
}
else
{
response.Message = "Something went wrong!";
response.IsSuccess = false;
}
return(response);
}
catch (Exception ex)
{
throw ex;
}
}
public AuthenticationResultModel Authenticate(LoginModel login)
{
var user = _userService.GetAllThenInclude(
u => u.Username.ToLower() == login.Username.ToLower(),
IncludeBuilder <User> .Include(u => u.UserRole).ThenInclude(userRole => userRole.Role).Done()
)
.SingleOrDefault();
//Return null if user not found
if (user == null)
{
return(null);
}
//Return null if the user doesn't have a password
if (string.IsNullOrWhiteSpace(user.PasswordHash))
{
return(null);
}
//Return null if the password is invalid
if (!PasswordHelper.ValidatePassword(login.Password, user.PasswordHash))
{
return(null);
}
//Authentication successful so generate jwt token
var token = GenerateToken(user);
var authenticationResultModel = new AuthenticationResultModel
{
UserId = user.Id,
Token = token
};
return(authenticationResultModel);
}
public async Task <IActionResult> SubmitAuthenticationResult([FromBody] AddAuthenticationResultModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var transaction = await _dbContext.Transactions.FindAsync(model.TransactionId);
if (transaction == null)
{
return(NotFound());
}
var device = _dbContext.Devices.FirstOrDefault(d => d.UserId == transaction.UserId);
if (device == null)
{
return(NotFound());
}
var authenticationResult = _dbContext.AuthenticationResults
.FirstOrDefault(a => a.TransactionId == model.TransactionId);
if (authenticationResult != null)
{
return(BadRequest("Authentication result already created for this transaction id"));
}
var verification = model.VerifySignature(device.PublicKey);
if (!verification)
{
return(BadRequest());
}
authenticationResult = new AuthenticationResultModel
{
ActualClientIP = model.ActualClientIP,
CertificateFingerprint = model.CertificateFingerprint,
ClientIPMatch = model.ClientIPMatch,
Result = model.Result,
ServerIP = model.ServerIP,
ServerURI = model.ServerURI,
TransactionId = model.TransactionId
};
await _dbContext.AddAsync(authenticationResult);
var result = await _dbContext.SaveChangesAsync();
if (result != 1)
{
return(StatusCode(500));
}
// Web apps will continue to query the database using the original transaction id
return(Ok());
}
