public string Login(LoginModelDTO model)
{
if (model is null)
{
throw new AccountException("Login model is null");
}
var user = userManager.FindByEmailAsync(model.Email).Result;
if (user != null && userManager.CheckPasswordAsync(user, model.Password).Result)
{
var roles = userManager.GetRolesAsync(user).Result;
var claims = new ClaimsService().GetClaims(user, roles);
if (claims != null)
{
var token = JWT_Service.GetToken(claims);
return(token);
}
else
{
throw new AccountException("Claims are null");
}
}
else
{
throw new AccountException("Password was not confirmed");
}
}
public async Task SetToken()
{
var loginModel = new LoginModelDTO {
Email = Constants.EMAIL, Password = Constants.PASSWORD
};
var response = await Client.PostAsync("/auth/login", ContentHelper.GetStringContent(loginModel));
var stream = await response.Content.ReadAsStreamAsync();
if (stream == null)
{
return;
}
var readStream = new StreamReader(stream, Encoding.UTF8);
var text = readStream.ReadToEnd();
dynamic body = JsonConvert.DeserializeObject <object>(text);
if (body == null)
{
return;
}
Client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", body.token.ToString());
}
public async Task <IActionResult> Login(LoginModelDTO User)
{
var RepoUser = await _Repo.Login(User.UserName, User.Password);
if (RepoUser == null)
{
return(Unauthorized());
}
#region GenerateAuthToken
var Claims = new [] {
new Claim(ClaimTypes.NameIdentifier, RepoUser.UserId.ToString()),
new Claim(ClaimTypes.Name, RepoUser.UserName)
};
var Key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Config.GetSection("AppSetting:AuthToken").Value));
var Cred = new SigningCredentials(Key, SecurityAlgorithms.HmacSha512);
var Tokendescriptor = new SecurityTokenDescriptor()
{
Subject = new ClaimsIdentity(Claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = Cred
};
var TokenHandler = new JwtSecurityTokenHandler();
var token = TokenHandler.CreateToken(Tokendescriptor);
#endregion
return(Ok(new { Token = TokenHandler.WriteToken(token) }));
}
public async Task <IActionResult> LogInAsync([FromBody] LoginModelDTO loginModel)
{
var tenants = await this._tenantService.GetTenantsAsync();
var tenant = tenants.FirstOrDefault(x =>
String.Compare(x.FirstName, loginModel.FirstName.Trim(), StringComparison.OrdinalIgnoreCase) == 0 &&
String.Compare(x.MiddleName, loginModel.MiddleName.Trim(), StringComparison.OrdinalIgnoreCase) == 0 &&
String.Compare(x.LastName, loginModel.LastName.Trim(), StringComparison.OrdinalIgnoreCase) == 0 &&
x.Apartment.ApartmentNumber == loginModel.ApartmentNumber);
if (tenant == null)
{
return(this.BadRequest(new { message = "Такой жилец не найден." }));
}
var tokenString = this.CreateJwtToken(tenant);
return(this.Ok(new
{
tenantTiny = new
{
IsAdmin = tenant.IsAdmin,
FullName = String.Format("{0} {1}.{2}.", tenant.LastName, tenant.FirstName[0], tenant.MiddleName[0]),
ApartmentNumber = tenant.Apartment.ApartmentNumber
},
token = tokenString
}));
}
public async Task <ResponseBase <List <Account> > > Login(LoginModelDTO loginModel)
{
var request = CreateRequest("login");
request.AddQueryParameter("email", loginModel.Username);
request.AddQueryParameter("password", loginModel.Password);
var response = await Client.GetAsync <ResponseBase <List <Account> > > (request);
return(response);
}
public async Task <IActionResult> Login([FromBody] LoginModelDTO model)
{
var user = await _userService.Authenticate(model.UserName, model.Password);
if (user == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
return(Ok(user));
}
public ActionResult Login(LoginModelDTO model, string returnUrl)
{
// check if all required fields are set
if (ModelState.IsValid)
{
if (ValidateUser(model.Email, WebUI.Controllers.API.Security.Crypto.Hash(model.Password), model.RememberMe))
{
return(RedirectToLocal(returnUrl));
}
}
// If we got this far, something failed, redisplay form
ModelState.AddModelError("", "The user name or password provided is incorrect.");
return(View(model));
}
public async Task <IActionResult> Login([FromBody] LoginModelDTO loginModelDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var repository = new AuthenticationRepository(this.context);
//Utilisateur userFound = repository.GetUtilisateurs().FirstOrDefault(u => u.Username == loginModelDTO.Username && u.MotDePasse == loginModelDTO.Password);
Utilisateur userFound = repository.GetUtilisateurs().FirstOrDefault(u => u.Username == loginModelDTO.Username && Bcrypt.Verify(loginModelDTO.Password, u.MotDePasse));
if (userFound == null)
{
return(Unauthorized());
}
var claims = new List <Claim> {
new Claim(JwtRegisteredClaimNames.Sub, userFound.Username),
new Claim(JwtRegisteredClaimNames.Jti, await _jwtOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat,
ToUnixEpochDate(_jwtOptions.IssuedAt).ToString(),
ClaimValueTypes.Integer64),
new Claim(PrivateClaims.UserId, userFound.Id.ToString())
};
//ADD role
if (userFound.UtilisateurRole != null)
{
userFound.UtilisateurRole.ToList().ForEach(u => claims.Add(new Claim("roles", u.IdRoleNavigation.Nom)));
}
JwtSecurityToken token = new JwtSecurityToken(
issuer: _jwtOptions.Issuer,
audience: _jwtOptions.Audience,
claims: claims,
notBefore: _jwtOptions.NotBefore,
expires: _jwtOptions.Expiration,
signingCredentials: _jwtOptions.SigningCredentials
);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(token);
var response = new{
access_token = encodedJwt,
expires_in = (int)_jwtOptions.ValidFor.TotalSeconds,
};
return(Ok(response));
}
public ViewResult LoginComplete(string returnUrl)
{
return(base.HandleOperationExecution(() =>
{
var owinContext = HttpContext.GetOwinContext();
var userNameClaim =
owinContext.Authentication.User.Claims.FirstOrDefault(Claim => Claim.Type == ClaimTypes.Name);
var model = new LoginModelDTO
{
ClientId = Startup.ClientId,
UserName = userNameClaim == null ? "" : userNameClaim.Value,
ReturnUrl = returnUrl
};
return View(model);
}));
}
public async Task <IActionResult> Login(LoginModel model, string ReturnUrl)
{
if (ModelState.IsValid)
{
LoginModelDTO lm = new LoginModelDTO()
{
Email = model.Email,
Password = model.Password
};
OperationDetails result = await accountService.Login(lm);
if (result.Succedeed)
{
return(RedirectToAction("Profile", "Home"));
}
else
{
ModelState.AddModelError("", "Неверный логин или пароль.");
}
}
return(View(model));
}
public async Task <IActionResult> Login([FromBody] LoginModelDTO model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(model.Email);
if (user != null && await _userManager.CheckPasswordAsync(user, model.Password))
{
var authClaims = new List <Claim>
{
new Claim(ClaimTypes.Name, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
};
var authSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:Key"]));
var token = new JwtSecurityToken
(
issuer: _configuration["Jwt:Issuer"],
audience: _configuration["Jwt:Issuer"],
expires: DateTime.Now.AddHours(3),
claims: authClaims,
signingCredentials: new SigningCredentials(authSigningKey, SecurityAlgorithms.HmacSha256)
);
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token),
expiration = token.ValidTo
}));
}
return(Unauthorized());
}
return(BadRequest(ModelState));
}
public async Task <OperationDetails> Login(LoginModelDTO lm)
{
var result = await signInManager.PasswordSignInAsync(lm.Email, lm.Password, true, true);
return(new OperationDetails(result.Succeeded, "", ""));
}
