private dynamic CreateToken(LoginAPIModel model)
{
var claims = new List <Claim> //using System.Security.Claims;
{
new Claim(JwtRegisteredClaimNames.Sub, model.Id.ToString()),
new Claim(ClaimTypes.Role, Enum.GetName(typeof(Roles), model.Role)), // ROLES !!!
new Claim(JwtRegisteredClaimNames.Nbf, new DateTimeOffset(DateTime.Now).ToUnixTimeSeconds().ToString()), //using System.IdentityModel.Tokens.Jwt;
new Claim(JwtRegisteredClaimNames.Exp, new DateTimeOffset(DateTime.Now.AddDays(1)).ToUnixTimeSeconds().ToString())
};
var token = new JwtSecurityToken(
new JwtHeader(
new SigningCredentials(
new SymmetricSecurityKey(
Encoding.UTF8.GetBytes("NobodyWillGuessMeLOL")), SecurityAlgorithms.HmacSha256)),
new JwtPayload(claims));
var output = new
{
id = model.Id,
role = Enum.GetName(typeof(Roles), model.Role),
token = new JwtSecurityTokenHandler().WriteToken(token) // Core will return props in camelCase
};
return(output);
}
public async Task <IActionResult> Login(LoginAPIModel model)
{
if (ModelState.IsValid)
{
Models.User user = await _context.Users
.Include(u => u.Role)
.FirstOrDefaultAsync(u => u.Email == model.Email && u.Password == model.Password);
if (user != null)
{
await Authenticate(user); // аутентификация
var messageReg = CreateCustomStatus.CreateCustomStatusM("200", "Успех авторизации");
return(Ok(messageReg));
}
else
{
ModelState.AddModelError("", "Неправильный логин и (или) пароль");
return(Ok(ModelState.Errors()));
}
}
else
{
return(Ok(new { Errors = ModelState.Errors() }));
}
}
public HttpResponseMessage Post([FromBody] LoginAPIModel user)
{
try
{
if (ModelState.IsValid)
{
UserAPIModel Luser = mapper.Map <UserAPIModel>(userBDC.AuthenticateUser(user.UserName, user.Password));
if (Luser != null)
{
return(Request.CreateResponse(HttpStatusCode.OK, Luser));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, Resources.AlreadyRegisteredUser));
}
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState));
}
}
catch (Exception)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, false));
}
}
public async Task <IActionResult> LoginAsync(LoginAPIModel model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user is null)
{
return(BadRequest("Incorrect User Name or Password"));
}
if (!user.EmailConfirmed)
{
return(BadRequest("Please confirm your email"));
}
var result = await _signInManager.CheckPasswordSignInAsync(user, model.Password, false);
if (!result.Succeeded)
{
return(BadRequest("Incorrect User Name or Password"));
}
var roles = await _userManager.GetRolesAsync(user);
IList <Claim> claims = await _userManager.GetClaimsAsync(user);
var token = _jwtToken.GenerateToken(user, roles, claims);
return(Ok(new
{
result = result,
username = user.Email,
email = user.Email,
firstName = user.FirstName.ToString(),
lastName = user.LastName.ToString(),
token = token,
userid = user.Id
}));
}
public string Login(LoginAPIModel model)
{
var response = webRequestHelper.Post("/api/account/login", JsonConvert.SerializeObject(model), "application/json; charset=UTF-8", "");
if (response.HasError)
{
return("");
}
return(response.ContainsHeader("Authorization") ? response["Authorization"] : "");
}
public async Task <IActionResult> Register([FromBody] LoginAPIModel registerModel)
{
var user = new ApplicationUser {
UserName = registerModel.UserID, Email = registerModel.UserID
};
var result = await _userManager.CreateAsync(user, registerModel.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : true);
_logger.LogInformation(3, "User created a new account with password.");
return(Ok());
}
// If we got this far, something failed.
return(ResponseHelper.Unauthorized());
}
public async Task <IActionResult> Login([FromBody] LoginAPIModel loginModel)
{
Microsoft.AspNetCore.Identity.SignInResult result = await _signInManager.PasswordSignInAsync(
loginModel.UserID, loginModel.Password, true, lockoutOnFailure : false);
if (result.Succeeded)
{
_logger.LogInformation(1, "User logged in.");
var signingKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_settings.Value.SecretKey));
var options = new TokenProviderOptions
{
Audience = "MuscleFellowAudience",
Issuer = "MuscleFellow",
SigningCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256),
};
TokenProvider tpm = new TokenProvider(options);
TokenEntity token = await tpm.GenerateToken(HttpContext, loginModel.UserID, loginModel.Password);
if (null != token)
{
return(new JsonResult(token));
}
else
{
return(NotFound());
}
}
if (result.IsLockedOut)
{
_logger.LogWarning(2, "User account locked out.");
return(Ok("Lockout"));
}
else
{
_logger.LogWarning(2, "Invalid login attempt.");
return(Ok("Invalid login attempt."));
}
}
public string TryLoginUser(LoginAPIModel model)
{
model.Password = Base64.Base64Decode(model.Password);
User user = cateringDbContext.Users
.Include(x => x.Role)
.Where(x => x.Email == model.Email || x.Username == model.Email)
.Where(x => x.PasswordHash == Sha256Helper.GetHash(model.Password))
.FirstOrDefault();
if (user == null)
{
return(null);
}
JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();
byte[] key = Encoding.ASCII.GetBytes(appSettings.Secret);
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, user.UserId.ToString()),
new Claim(JwtRegisteredClaimNames.UniqueName, $"{user.FirstName} {user.LastName}"),
new Claim(ClaimTypes.Role, user.Role.RoleTitle)
};
SigningCredentials signingCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
SigningCredentials = signingCredentials
};
SecurityToken token = tokenHandler.CreateToken(tokenDescriptor);
return(tokenHandler.WriteToken(token));
}
public IActionResult Login([FromBody] LoginAPIModel model)
{
string token = userService.TryLoginUser(model); //Returns a valid JWT token if logged in successfuly, NULL if not
if (token == null)
{
return(Unauthorized());
}
CookieOptions cookieOptions = new CookieOptions
{
IsEssential = true,
Expires = new DateTimeOffset(DateTime.Now.AddYears(1))
};
if (model.RememberMe == true)
{
cookieOptions.Expires = DateTime.Now.AddYears(10);
}
Response.Cookies.Append("token", token, cookieOptions);
return(Ok());
}
