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 <IActionResult> Login([FromBody] AuthenticationRequestModel userForAuthentication)
{
var user = await _userManager.FindByNameAsync(userForAuthentication.UserName);
if (user == null)
{
return(StatusCode(401, new AuthenticationResponseModel {
ErrorMessage = "No such user"
}));
}
if (!await _userManager.CheckPasswordAsync(user, userForAuthentication.Password))
{
return(StatusCode(401, new AuthenticationResponseModel {
ErrorMessage = "Wrong password"
}));
}
if (user.IsBanned)
{
return(StatusCode(401, new AuthenticationResponseModel {
ErrorMessage = "User is banned"
}));
}
var tokens = await _jwtHandler.GenerateTokensForUser(user);
return(Ok(new AuthenticationResponseModel {
IsAuthSuccessful = true, Tokens = tokens
}));
}
public async Task <AuthenticationResponseModel> Authenticate(AuthenticationRequestModel model)
{
if (model.grant_type == "password")
{
if (model.scope == "my cool app")
{
var userEntity = await userStore.FindUserProfile(model.client_id);
if (userEntity == null)
{
return(null);
}
if (userEntity.Password == model.client_secret)
{
var token = await jWTFactoryService.CreateToken(userEntity);
return(new AuthenticationResponseModel
{
access_token = token,
token_type = "Bearer"
});
}
}
}
return(null);
}
public async Task <IActionResult> AuthenticateByUserPass(AuthenticationRequestModel model)
{
var authenticationResult = await _authenticationService.GenerateJwtByUserPass(model);
Response.SetRefreshToken(authenticationResult.RefreshToken);
return(Ok(authenticationResult));
}
public async Task <AuthenticationResponseModel> GetTokenAsync(AuthenticationRequestModel model)
{
var response = new AuthenticationResponseModel();
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
response.IsAuthenticated = false;
response.Message = $"No Accounts Registered with {model.Email}.";
return(response);
}
if (await _userManager.CheckPasswordAsync(user, model.Password))
{
response.IsAuthenticated = true;
JwtSecurityToken jwtSecurityToken = await CreateJwtToken(user);
response.Token = new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken);
response.Email = user.Email;
response.UserName = user.UserName;
var rolesList = await _userManager.GetRolesAsync(user).ConfigureAwait(false);
response.Roles = rolesList.ToList();
return(response);
}
response.IsAuthenticated = false;
response.Message = $"Incorrect Credentials for user {user.Email}.";
return(response);
}
public async Task <TokensResponseModel> Loggin(AuthenticationRequestModel authenticationRequestModel, [FromServices] IJwtSigningEncodingKey signingEncodingKey)
{
var result = await _userService.Loggin(await _userService.GetIdByEmail(authenticationRequestModel.Email), authenticationRequestModel.Password);
var id = await _userService.GetIdByEmail(authenticationRequestModel.Email);
User user = await _userManager.FindByIdAsync(id);
var roles = await _userManager.GetRolesAsync(user);
string role = roles.FirstOrDefault();
if (result.Succeeded)
{
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.NameIdentifier, authenticationRequestModel.Email),
new Claim(ClaimTypes.Role, role)
};
var refreshClaims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.NameIdentifier, authenticationRequestModel.Email)
};
var token = new JwtSecurityToken(
issuer: "Test",
audience: "Bookstore",
claims: claims,
expires: DateTime.Now.AddMinutes(10),
signingCredentials: new SigningCredentials(signingEncodingKey.GetKey(), signingEncodingKey.SigningAlgorithm)
);
var refreshToken = new JwtSecurityToken(
issuer: "Test",
audience: "Bookstore",
claims: refreshClaims,
expires: DateTime.Now.AddDays(60),
signingCredentials: new SigningCredentials(signingEncodingKey.GetKey(), signingEncodingKey.SigningAlgorithm)
);
string jwtToken = new JwtSecurityTokenHandler().WriteToken(token);
string refreshJwtToken = new JwtSecurityTokenHandler().WriteToken(refreshToken);
TokensResponseModel tokensResponseModel = new TokensResponseModel();
tokensResponseModel.AccessToken = jwtToken;
tokensResponseModel.RefreshToken = refreshJwtToken;
tokensResponseModel.Role = role;
tokensResponseModel.Id = user.Id;
await _userManager.SetAuthenticationTokenAsync(user, String.Empty, "RefreshToken", refreshJwtToken);
return(tokensResponseModel);
}
return(null);
}
public async Task <IActionResult> Auth(AuthenticationRequestModel model)
{
try
{
return(Ok(await authenticationService.Authenticate(model)));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IResponse Authentication(AuthenticationRequestModel authentication)
{
var auth = _mapperAdapter.Map <AuthenticationRequestModel, Authentication>(authentication);
var token = _authService.Authentication(auth);
if (token == Guid.Empty)
{
return(new AuthenticationOkResponseModel("Email/Cpf or Senha invalid."));
}
return(_mapperAdapter.Map <Guid, AuthenticationOkResponseModel>(token));
}
public static void Test_Can_JSON_Serialize_To_NonNull_Non_Whitespace(string username, string password)
{
//arrange
AuthenticationRequestModel authModel = new AuthenticationRequestModel(username, password);
//act
string serializedModel = JsonConvert.SerializeObject(authModel);
//assert
Assert.NotNull(serializedModel);
Assert.IsNotEmpty(serializedModel);
Assert.True(serializedModel.Contains(username));
//password may not be contained depending
}
public async Task <IActionResult> Register(AuthenticationRequestModel request)
{
var result = await _service.Register(request.UserName, request.Password);
if (result.Success)
{
return(Ok(new AuthenticationRegistrationResponseModel()));
}
var responseError = new AuthenticationRegistrationResponseModel()
{
Errors = result.Errors,
Success = false
};
return(BadRequest(responseError));
}
public static void Test_Can_JSON_Serialize_Then_Deserialize_With_Preserved_Values(string username, string password)
{
//arrange
AuthenticationRequestModel authModel = new AuthenticationRequestModel(username, password);
//act
AuthenticationRequestModel deserializedModel =
JsonConvert.DeserializeObject <AuthenticationRequestModel>(JsonConvert.SerializeObject(authModel));
//assert
Assert.NotNull(deserializedModel);
Assert.NotNull(deserializedModel.UserName);
Assert.NotNull(deserializedModel.Password);
Assert.AreEqual(username, deserializedModel.UserName);
//password may not be contained depending
}
public IActionResult Authentication([FromBody] AuthenticationRequestModel authentication)
{
if (authentication.IsValid())
{
var response = _authAppService.Authentication(authentication);
return(new ObjectResult(response)
{
StatusCode = response.StatusCode()
});
}
var badRequest = new BadRequestResponse("The fields E-mail/Cpf and Senha are required");
return(new ObjectResult(badRequest)
{
StatusCode = badRequest.StatusCode()
});
}
public static AuthenticationRequestLogic Create(AuthenticationRequestModel model, AdaptersExtender adaptersExtender, CityLogic city)
{
switch (model.ParticipantType)
{
case ParticipantTypes.Driver:
return(new DriverAuthenticationRequestLogic((DriverAuthenticationRequestModel)model, adaptersExtender, city));
break;
case ParticipantTypes.Pedestrian:
return(new PedestrianAuthenticationRequestLogic((PedestrianAuthenticationRequestModel)model, adaptersExtender, city));
break;
default:
throw new NotImplementedException();
break;
}
}
public HttpResponseMessage GetToken(AuthenticationRequestModel authModel)
{
if (ModelState.IsValid)
{
string token = _securityService.Login(authModel);
if (token != null)
{
return Request.CreateResponse(HttpStatusCode.OK, new TokenResponse {token = token});
}
return Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "User name or password is not valid");
}
else
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Credentials provided are invalid");
}
}
public ActionResult <ProfileLogic> Authenticate(AuthenticationRequestModel requestModel)
{
requestModel.DeviceId = _adaptersExtender.ServicesFactory.GetCurrentHardwareService().GetDeviceId();
//ActionResult<MapPoint> locationResult = _adaptersExtender.ServicesFactory.GetCurrentHardwareService().GetCurrentLocation();
//if (!locationResult.IsValid)
// return ActionResult<ProfileLogic>.GetErrorResult(new HardwareServiceException(HardwareServiceErrors.NoLocationService));
if (!_interaction.CurrentLocation.HasValue)
{
return(ActionResult <ProfileLogic> .GetErrorResult(new HardwareServiceException(HardwareServiceErrors.NoLocationService)));
}
requestModel.CurrentLocation = _interaction.CurrentLocation.Value;
AuthenticationRequestLogic authenticationRequestLogic = AuthenticationRequestLogic.Create(requestModel, _adaptersExtender, this);
ActionResult <ProfileLogic> result = authenticationRequestLogic.Authenticate();
if (result.IsValid)
{
_interaction.CurrentProfile = result.Result;
}
return(result);
}
public async Task <IActionResult> Login(AuthenticationRequestModel request)
{
var result = await _service.Login(request.UserName, request.Password);
if (result.Success) //uspjesna prijava
{
var responseSuccess = new AuthenticationLoginReponseModel()
{
Token = result.Token
};
return(Ok(responseSuccess));
}
var responseError = new AuthenticationLoginReponseModel()
{
Errors = result.Errors,
Success = false
};
return(BadRequest(responseError));
}
public async Task <IActionResult> Authenticate([FromBody] AuthenticationRequestModel model)
{
User user = null;
string tokenString;
string refreshToken;
try
{
user = await UserService.AuthenticateAsync(model.Username, model.Password);
if (user == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
tokenString = AccessTokenService.GenerateAccessToken(user.Id.ToString());
refreshToken = AccessTokenService.GenerateRefreshToken();
await AccessTokenService.SaveRefreshTokenAsync(user.Id.ToString(), refreshToken);
}
catch (ArgumentException e)
{
return(BadRequest(e.Message));
}
catch
{
return(StatusCode(500));
}
return(Ok(new
{
id = user.Id,
username = user.Username,
token = tokenString,
refreshToken = refreshToken
}));
}
private void RunAuthentication()
{
RadioButton pedestrianRadioButton = FindViewById <RadioButton>(Resource.Id.pedestrianRadioButton);
RadioButton driverRadioButton = FindViewById <RadioButton>(Resource.Id.driverRadioButton);
AuthenticationRequestModel request = null;// _model.CreateAuthenticationRequest(, null);
if (pedestrianRadioButton.Checked)
{
request = _model.CreateAuthenticationRequest(ParticipantTypes.Pedestrian);
FillPedestrianRequest((PedestrianAuthenticationRequestModel)request);
}
else if (driverRadioButton.Checked)
{
request = _model.CreateAuthenticationRequest(ParticipantTypes.Driver);
FillDriverRequest((DriverAuthenticationRequestModel)request);
}
else
{
using (Toast errorToast = Toast.MakeText(Application.BaseContext, Resources.GetString(Resource.String.NoParticipationRole), ToastLength.Short))
errorToast.Show();
return;
}
_model.BeginAuthenticate(request);
}
public string Login(AuthenticationRequestModel authModel)
{
throw new NotImplementedException();
}
public string GetTestValue([FromBody] AuthenticationRequestModel authenticationRequestModel)
{
return("Authorization is working");
}
public async Task <IActionResult> GetTokenAsync(AuthenticationRequestModel model)
{
var result = await _loginService.GetTokenAsync(model);
return(Ok(result));
}
public string Login(AuthenticationRequestModel requestModel)
{
UserAuth userAuth = GetUserAuth(requestModel.Username);
if (TestCryptoKey(requestModel.Password, new CryptoKey { Hash = userAuth.Password, Salt = userAuth.Salt }))
{
byte[] hToken = new byte[32];
CryptProvider.GetBytes(hToken);
string token = Convert.ToBase64String(hToken).Replace("=", "").Replace("+","").Replace("/","");
if (SecurityRepository.SetUserToken(userAuth.id, token))
{
return token;
}
}
return null;
}
public AuthenticationRequestLogic(AuthenticationRequestModel model, AdaptersExtender adaptersExtender, CityLogic city)
{
_model = model;
_adaptersExtender = adaptersExtender;
_city = city;
}