public async Task <IActionResult> Login([FromBody] User request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = await _bus.Send(new GetUserCommand(request));
if (user == null)
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.Name, request.Username),
new Claim(ClaimTypes.SerialNumber, request.Password),
new Claim(ClaimTypes.Role, "User")
};
var jwtResult = _jwtAuthManager.GenerateTokens(request.Username, claims, DateTime.Now);
return(Ok(new LoginResult
{
UserName = request.Username,
Role = "User",
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
}));
}
public async Task <IActionResult> Register([FromBody] RegisterRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = await _userService.RegisterUser(request.Username, request.Password, request.Email);
if (user == null)
{
return(BadRequest("user already exist"));
}
var claims = new[] {
new Claim(ClaimTypes.Name, user.UserName),
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
};
var jwtResult = _jwtAuthManager.GenerateTokens(user.UserName, claims, DateTime.Now);
LoginResponse loginResult = new LoginResponse
{
Username = user.UserName,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString,
};
SetTokenCookie(jwtResult.AccessToken);
return(Ok(loginResult));
}
public async Task <ActionResult> Login([FromBody] LoginRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!await _userService.IsValidUserCredentials(request.Username, request.Password))
{
return(Unauthorized());
}
var role = await _userService.GetUserRole(request.Username);
var claims = new[]
{
new Claim(ClaimTypes.Name, request.Username),
new Claim(ClaimTypes.Role, role)
};
var jwtResult = _jwtAuthManager.GenerateTokens(request.Username, claims, DateTime.Now);
_logger.LogInformation($"User [{request.Username}] logged in the system.");
return(Ok(new LoginResult
{
UserName = request.Username,
Role = role,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
}));
}
public async Task <ActionResult> Login([FromBody] LoginRequest loginRequest)
{
Console.WriteLine("customer/login end-point");
if (!ModelState.IsValid)
{
return(BadRequest());
}
var jsonLoginRequest = JsonConvert.SerializeObject(loginRequest);
var client = new RestClient("http://localhost:8080/");
var request = new RestRequest("auth/customer/login", Method.POST)
{
RequestFormat = DataFormat.Json
};
request.AddJsonBody(jsonLoginRequest);
var response = await client.ExecuteAsync(request);
if (response.IsSuccessful)
{
Console.WriteLine(response.Content);
Customer foundCustomer = JsonConvert.DeserializeObject <Customer>(response.Content);
Console.WriteLine(foundCustomer.FirstName + foundCustomer.LastName);
var jwtResult = _jwtAuthManager.GenerateTokens(foundCustomer, new Claim[0], DateTime.Now);
return(Ok(new LoginResult
{
Id = foundCustomer.Id,
Email = loginRequest.Email,
FirstName = foundCustomer.FirstName,
LastName = foundCustomer.LastName,
Role = "customer",
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
}));
}
return(Unauthorized());
// if (!_userService.IsValidUserCredentials(request.UserName, request.Password))
// {
// return Unauthorized();
// }
// var role = _userService.GetUserRole(request.UserName);
// var claims = new[]
// {
// new Claim(ClaimTypes.Name,request.UserName),
// new Claim(ClaimTypes.Role, role)
// };
}
public ActionResult Login([FromBody] LoginRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!_userService.IsValidUserCredentials(request.user_name, request.password))
{
return(Unauthorized());
}
var idrole = _userService.GetUserIDAndRole(request.user_name);
var claims = new[]
{
new Claim(ClaimTypes.Name, request.user_name),
new Claim(ClaimTypes.Role, idrole.Item2)
};
var jwtResult = _jwtAuthManager.GenerateTokens(request.user_name, claims, DateTime.Now);
_logger.LogInformation($"User [{request.user_name}] logged in the system.");
return(Ok(new LoginResult
{
user_id = idrole.Item1.ToString(),
user_name = request.user_name,
role = idrole.Item2,
access_token = jwtResult.access_token,
refresh_token = jwtResult.refresh_token.token_string
}));
}
public async Task <ActionResult> Login([FromBody] User user)
{
if (user == null)
{
return(BadRequest());
}
var result = await userRepository.ValidateUser(user.UserName, user.Password);
if (result != null)
{
var role = result.Role;
var claims = new[]
{
new Claim(ClaimTypes.Name, result.UserName),
new Claim(ClaimTypes.Role, role)
};
var jwtResult = jwtAuthManager.GenerateTokens(result.UserName, claims, DateTime.Now);
logger.LogInformation($"User [{result.UserName}] logged in the system.");
return(Ok(new LoginResult
{
UserName = result.UserName,
Role = role,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
}));
}
else
{
return(Unauthorized("Login failed"));
}
}
public async Task <ActionResult <LoginResult> > login([FromBody] UserCreditials creditials)
{
var user = await _userResource.Login(creditials.UserName, creditials.Password);
if (user.UserId == 0)
{
return(BadRequest());
}
var claims = new[]
{
new Claim(ClaimTypes.Name, creditials.UserName),
new Claim(ClaimTypes.NameIdentifier, user.UserId.ToString())
};
var jwtResult = _jwtAuthManager.GenerateTokens(user.UserId, creditials.UserName, claims, DateTime.Now);
return(Ok(new LoginResult
{
Username = user.Username,
AvatarFilePath = user.AvatarFilePath,
Color = user.Color,
Email = user.Email,
UserId = user.UserId,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
}));
}
public async Task <IActionResult> Login([FromBody] LoginRequest request)
{
var user = await _userService.GetUserByLogin(request.Login);
var userRole = await _roleService.GetRoleIdyById(user.RoleId);
if (user == null)
{
return(BadRequest("Пользователь с таким именем не зарегистрирован!"));
}
using (var hmac = new HMACSHA512(user.PasswordSalt))
{
var computesHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(request.Password));
for (int i = 0; i < computesHash.Length; i++)
{
if (computesHash[i] != user.PasswordHash[i])
{
return(Unauthorized("Пользователь с таким именем не зарегистрирован!"));//ошибка авторизации. не смог авторизоваться
}
}
}
JwtAuthResult jwtResult;
var claims = new[]
{
new Claim(ClaimTypes.Name, request.Login),
new Claim(ClaimTypes.Role, userRole.Name)
};
jwtResult = _jwtAuthManager.GenerateTokens(request.Login, claims);
return(Ok(jwtResult));
}
public async Task <ActionResult <LoginResult> > GetUserLogin([FromBody] Credential credential)
{
if (ModelState.IsValid)
{
User user = await _userProvider.GetUserLogin(credential.Username, credential.Password);
if (user != null)
{
var claims = new[]
{
new Claim(ClaimTypes.Name, user.Credential.Username),
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
new Claim(ClaimTypes.Role, "Member")
};
var jwtResult = _jwtAuthManager.GenerateTokens(user.Credential.Username, claims, DateTime.Now);
LoginResult result = new LoginResult
{
Username = user.Credential.Username,
UserId = user.Id,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
};
return(Ok(result));
}
else
{
return(NoContent());
}
}
return(BadRequest());
}
public ActionResult Login([FromBody] LoginRequest request)
{
if (String.IsNullOrEmpty(request.username) || String.IsNullOrEmpty(request.password))
{
return(BadRequest());
}
if (!_userService.IsValidUserCredentials(request.username, request.password))
{
return(Unauthorized());
}
User user = _userService.findUserByUserName(request.username);
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, request.username),
new Claim("Id", request.username)
};
if (user.isAdmin)
{
claims.Add(new Claim("Role", "admin"));
}
var jwtResult = _jwtAuthManager.GenerateTokens(request.username, claims.ToArray(), DateTime.Now);
_logger.LogInformation($"User [{request.username}] logged in the system.");
return(Ok(new LoginResult
{
username = request.username,
accessToken = jwtResult.accessToken,
refreshToken = jwtResult.refreshToken.tokenString
}));
}
public async Task <IActionResult> Post([FromBody] UserDTO userDTO)
{
var user = await _userAppService.GetAsync(userDTO.Login, userDTO.Password);
if (user == null)
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.Name, user.Login),
new Claim(ClaimTypes.Role, "Admin")
};
var jwtResult = _jwtAuthManager.GenerateTokens(user.Login, claims, DateTime.Now);
return(Ok(new
{
UserName = userDTO.Login,
Role = "Admin",
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
}));
}
public async Task <IActionResult> AuthenticateUser([FromBody] AuthenticateUserDto authUser)
{
ServiceResponse <GetUserDto> response = await _userService.AuthenticateUser(authUser);
if (response.Data == null)
{
return(Unauthorized(response));
}
else
{
ServiceResponse <JwtTokens> respjwtTokens = new ServiceResponse <JwtTokens>();
_jwtAuthManager.RemoveRefreshTokenByUserName(authUser.Email);
var claims = new[]
{
new Claim("Email", authUser.Email),
new Claim("Role", "role"),
new Claim("Activated", response.Data.Status == UserStatus.Disabled ? "False": "True")
};
var jwtResult = _jwtAuthManager.GenerateTokens(authUser.Email, claims, DateTime.Now);
_logger.LogInformation($"User [{authUser.Email}] logged in the system.");
JwtTokens jwtTokens = new JwtTokens();
jwtTokens.AccessToken = jwtResult.AccessToken.ToString();
jwtTokens.RefreshToken = jwtResult.RefreshToken.TokenString;
respjwtTokens.Data = jwtTokens;
respjwtTokens.Message = "Validated";
return(Ok(jwtResult));
}
}
public ActionResult Login([FromBody] LoginRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var CurrentUser = _userService.GetUserByEmail(request.Email);
if (CurrentUser == null || !BC.Verify(request.Password, CurrentUser.Password))
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.Name, CurrentUser.UserName),
new Claim(ClaimTypes.Email, CurrentUser.Email)
};
var jwtResult = _jwtAuthManager.GenerateTokens(CurrentUser.UserName, claims, DateTime.Now);
_logger.LogInformation($"User [{CurrentUser.UserName}] logged in the system.");
return(Ok(new LoginResult
{
UserId = CurrentUser.Id,
UserName = CurrentUser.UserName,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString,
Email = CurrentUser.Email,
IsEmailConfirmed = CurrentUser.IsEmailConfirmed,
ShippingAddress = CurrentUser.ShippingAddress,
Orders = CurrentUser.Orders
}));
}
public ActionResult <LoginResult> Login([FromBody] LoginRequest request)
{
if (!_flightCenterSystem.TryLogin(request.UserName, request.Password, out ILoginToken loginToken, out FacadeBase facade))//validate the login credentials
{
return(Unauthorized());
}
dynamic user = loginToken.GetType().GetProperties()[0].GetValue(loginToken); //Get the user from the login token as dynamic object
string role = user.User.UserRole.ToString(); //get the user role
var claims = new[] //generate claims array
{
new Claim(ClaimTypes.Name, user.User.UserName),
new Claim(ClaimTypes.NameIdentifier, user.User.Id.ToString()),
new Claim(ClaimTypes.Role, role),
new Claim("LoginToken", loginToken.ToString()),
};
var jwtResult = _jwtAuthManager.GenerateTokens(request.UserName, claims, DateTime.Now);//Invoke GenerateTokens and get JWTAuthResult
_logger.LogInformation($"User [{request.UserName}] logged in the system.");
return(Ok(new LoginResult
{
UserName = request.UserName,
Role = role,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
}));
}
public async Task <IActionResult> SignUp(LoginRequest request)
{
var result = await _usersService.TryInsertIfUniqueAsync(request);
if (result == null)
{
return(Unauthorized("Username exists. Try another one"));
}
var claims = _jwtAuthManager.GenerateClaims(result.UserId, result.UserName);
var jwtResult = _jwtAuthManager.GenerateTokens(result.UserId, result.UserName, claims, DateTime.Now);
result.AccessToken = jwtResult.AccessToken;
result.RefreshToken = jwtResult.RefreshToken.TokenString;
return(Ok(result));
}
public async Task <IActionResult> LogIn(string userName, string password)
{
try
{
if (userName == null || password == null)
{
return(BadRequest());
}
var result = await _signInManager.PasswordSignInAsync(userName, password, false, lockoutOnFailure : false);
if (!result.Succeeded)
{
return(Unauthorized("Wrong Password"));
}
//asgakini islet
//if (!passwordOK)
// return StatusCode(StatusCodes.Status401Unauthorized, "Incorrect username or password");
// ########### Belke lazim olar deye
//if (existingUser == null)
//{
// response = Request.CreateResponse(HttpStatusCode.NotFound);
//}
//else
//{
// var loginSuccess =
// string.Equals(EncryptPassword(model.Password, existingUser.Salt),
// existingUser.PasswordHash);
var userId = _unitOfWork.UserApplication.FirstOrDefault(u => u.UserName == userName).Id;
var claims = new[] {
new Claim(ClaimTypes.NameIdentifier, userId),
new Claim(ClaimTypes.Name, userName),
new Claim(ClaimTypes.Role, "Manager"),
new Claim(JwtRegisteredClaimNames.UniqueName, userName),
new Claim(JwtRegisteredClaimNames.Sub, userName),
new Claim(JwtRegisteredClaimNames.Email, userName)
};
var jwtResult = _jwtAuthManager.GenerateTokens(userName, claims, DateTime.Now);
var UserName = User.Identity.Name;
return(Ok(new LoginResult
{
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken,
UserName = userName
}));
}
catch (Exception ex)
{
return(Json(new { success = false, data = ex.Message + "\n" + ex.InnerException.Message }));
}
}
private JwtAuthResult JwtAuthResult(string userId, string email)
{
var claims = new[]
{
new Claim(ClaimTypes.Name, userId)
};
var jwtResult = _jwtAuthManager.GenerateTokens(email, claims, DateTime.Now);
return(jwtResult);
}
public async Task <LoginResult> AuthenticateAsync(LoginRequest request)
{
var CurrentUser = await userServices.GetUserByEmailAsync(request.Email);
if (CurrentUser == null)
{
throw new Exception($"User with {request.Email} not found.");
}
if (request.Email == configuration["ShopOwner:Email"] && request.Password == configuration["ShopOwner:Password"])
{
CurrentUser = new User
{
Id = "maxshopowner",
Email = request.Email,
Password = BC.HashPassword(request.Password),
Role = UserRoles.MaxShopOwner,
UserName = "******",
IsEmailConfirmed = true
};
}
if (!BC.Verify(request.Password, CurrentUser.Password))
{
throw new Exception($"Credentials for '{request.Email} aren't valid'.");
}
var claims = new[]
{
new Claim(ClaimTypes.Name, CurrentUser.UserName),
new Claim(ClaimTypes.Email, CurrentUser.Email),
new Claim(ClaimTypes.Role, CurrentUser.Role)
};
var jwtResult = jwtAuthManager.GenerateTokens(CurrentUser.UserName, claims, DateTime.Now);
logger.LogInformation($"User [{request.Email}] logged in the system.");
return(new LoginResult
{
UserId = CurrentUser.Id,
Role = CurrentUser.Role,
UserName = CurrentUser.UserName,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString,
Email = CurrentUser.Email,
IsEmailConfirmed = CurrentUser.IsEmailConfirmed,
Contact = CurrentUser.Contact,
});
}
public async Task <CustomerAuthViewModel> AuthenticateAsync(string email, string password)
{
var passwordHashed = AuthenticateHelper.HashPassword(password);
var customer = await _customerRepository.AuthenticateCustomerAsync(email, passwordHashed);
if (customer == null)
{
return(null);
}
var claims = new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, customer.Id.ToString()),
new Claim(ClaimTypes.Name, email),
new Claim("Scope", "Customer")
};
var jwtResult = _jwtAuthManager.GenerateTokens(email, claims, DateTime.Now);
return(new CustomerAuthViewModel
{
Customer = customer,
JwtResult = jwtResult
});
}
public ActionResult Login([FromBody] LoginRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var CurrentUser = _userService.GetUserByEmail(request.Email);
if (request.Email == _configuration["ShopOwner:Email"] && request.Password == _configuration["ShopOwner:Password"])
{
CurrentUser = new User
{
Id = "maxshopowner",
Email = request.Email,
Password = BC.HashPassword(request.Password),
Role = UserRoles.MaxShopOwner,
UserName = "******",
IsEmailConfirmed = true
};
}
if (CurrentUser == null || !BC.Verify(request.Password, CurrentUser.Password))
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.Name, CurrentUser.UserName),
new Claim(ClaimTypes.Email, CurrentUser.Email),
new Claim(ClaimTypes.Role, CurrentUser.Role)
};
var jwtResult = _jwtAuthManager.GenerateTokens(CurrentUser.UserName, claims, DateTime.Now);
return(Ok(new LoginResult
{
UserId = CurrentUser.Id,
Role = CurrentUser.Role,
UserName = CurrentUser.UserName,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString,
Email = CurrentUser.Email,
IsEmailConfirmed = CurrentUser.IsEmailConfirmed,
Contact = CurrentUser.Contact,
Notifications = CurrentUser.Notifications
}));
}
private string CreateToken(User user)
{
_jwtAuthManager.RemoveRefreshTokenByUserName(user.Name);
var claims = new[]
{
new Claim("Email", user.Name),
new Claim("Role", "role"),
new Claim("Activated", user.Status == UserStatus.Enabled ? "Yes": "No"),
new Claim("Id", user.Id.ToString()),
new Claim("Name", user.Name)
};
var jwtResult = _jwtAuthManager.GenerateTokens(user.Name, claims, DateTime.Now);
return(jwtResult.AccessToken);
}
public ActionResult LoginUser([FromBody] string credentials)
{
string responseData = string.Empty;
UserInputModel requestData = JsonConvert.DeserializeObject <UserInputModel>(credentials);
UserInputModel userData = _userService.ValidateCredentials(requestData);
UserViewModel user = new UserViewModel();
if (userData != null)
{
user.userDetails = userData;
string userType = Enum.GetName(typeof(USERTYPE), userData.User_Type_Id);
string role = Enum.GetName(typeof(USERROLE), userData.User_Role_Id);
Claim[] claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, userData.Id.ToString()),
new Claim(ClaimTypes.Role, role)
};
var jwtResult = _jwtAuthManager.GenerateTokens(userData.Id.ToString(), claims, DateTime.Now);
_logger.LogInformation($"User [{userData.Id}] logged in the system.");
UserTokenModel userToken = new UserTokenModel()
{
UserId = userData.Id,
Token = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString,
RefreshTokenExpiration = jwtResult.RefreshToken.ExpireAt,
Created_On = DateTime.Now
};
user.userToken = userToken;
if (userToken.Token.Length > 0)
{
responseData = JsonConvert.SerializeObject(user);
}
}
else
{
user = null;
}
return(Ok(user));
}
public LoginResult Login(string login, string password)
{
var zaposlenik = context.Zaposlenici.FirstOrDefault(z => z.Login == login && z.Password == password);
if (zaposlenik != null)
{
var claims = new[]
{
new Claim(ClaimTypes.GivenName, login)
};
var jwtResult = jwtAuthManager.GenerateTokens(login, claims, DateTime.Now);
var loginResult = new LoginResult
{
Zaposlenik = zaposlenik,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
};
return(loginResult);
}
return(null);
}
public LoginResult Login(string email, string password)
{
var user = context.Users.FirstOrDefault(u => u.Email == email && u.Password == password);
if (user != null)
{
var claims = new[]
{
new Claim(ClaimTypes.Email, email)
};
var jwtResult = jwtAuthManager.GenerateTokens(email, claims, DateTime.Now);
var loginResult = new LoginResult
{
User = user,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
};
return(loginResult);
}
return(null);
}
public async Task <ApplicationResponse <LoginResponseDto> > Authenticate(LoginRequestDto authenticateRequest)
{
var userByMail = await _userRepository.GetAsync(x => x.EMail == authenticateRequest.EMail);
if (userByMail is null)
{
return(new ApplicationResponse <LoginResponseDto>(ResponseState.Error,
ResponseMessage.Error.UserNotFound));
}
var hashPassword = SecurityHelper.HashPassword(authenticateRequest.Password, userByMail.PasswordSalt);
var user = await _userRepository.GetAsync(x =>
x.EMail == authenticateRequest.EMail && x.Password == hashPassword);
if (user is null)
{
return(new ApplicationResponse <LoginResponseDto>(ResponseState.Error,
ResponseMessage.Error.UserNotFound));
}
var claims = new List <Claim>
{
new("id", user.Id),
new("email", user.EMail),
};
var jwtResult = _jwtAuthManager.GenerateTokens(user.EMail, claims.ToArray());
await _tokenManager.AssignToken(jwtResult.AccessToken, jwtResult.RefreshToken);
return(new ApplicationResponse <LoginResponseDto>(new LoginResponseDto
{
Id = user.Id,
Name = user.Name,
Surname = user.Surname,
Mail = user.EMail,
Company = user.Company?.Name,
AccessToken = jwtResult.AccessToken,
}));
}
public async Task <IActionResult> Post(UserLoginModel loginUser)
{
if (loginUser != null)
{
var existingUser = await _userManager.FindByNameAsync(loginUser.UserName);
var passwordMatch = _userManager.PasswordHasher.VerifyHashedPassword(existingUser, existingUser.PasswordHash, loginUser.Password);
if (existingUser != null && passwordMatch.Equals(PasswordVerificationResult.Success))
{
var claims = new[] {
new Claim(ClaimTypes.Name, loginUser.UserName)
};
var jwtResult = _jwtManager.GenerateTokens(loginUser.UserName, claims, DateTime.Now);
return(new OkObjectResult(new UserLoginResultModel {
UserName = loginUser.UserName,
AccessToken = jwtResult.AccessToken
}));
}
}
return(new UnauthorizedObjectResult("Incorrect login credentials."));
}
public async Task <ActionResult> LoginAsync([FromBody] LoginRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!(await _userService.IsValidUserCredentialsAsync(request.UserName, request.Password)))
{
return(Unauthorized());
}
JwtAuthResult jwtResult = _jwtAuthManager.GenerateTokens(request.UserName, new Claim[] { }, DateTime.Now);
_logger.LogInformation($"User [{request.UserName}] logged in the system.");
return(Ok(new LoginResult
{
UserName = request.UserName,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
}));
}
public async Task <ActionResult> Login([FromBody] LoginRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!await _userService.IsValidUserCredentials(request.Email, request.Password))
{
return(Unauthorized());
}
// var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var User = _userService.GetUser(request.Email, request.Password);
var claims = new[]
{
new Claim(ClaimTypes.Name, request.Email),
new Claim("UserId", Convert.ToString(User.Result.UserId)),
new Claim("Username", User.Result.FirstName + ' ' + User.Result.LastName),
new Claim("TypeUser", User.Result.TypeUser),
new Claim("CreatedByAdminID", User.Result.CreatedByAdminID.ToString())
};
var jwtResult = _jwtAuthManager.GenerateTokens(request.Email, claims, DateTime.Now);
// _logger.LogInformation($"User [{request.Email}] logged in the system.");
return(Ok(new LoginResult
{
Email = request.Email,
UserId = User.Result.UserId,
Username = User.Result.FirstName + ' ' + User.Result.LastName,
TypeUser = User.Result.TypeUser,
CreatedByAdminID = User.Result.CreatedByAdminID,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
}));
}
public IActionResult Login([FromBody] User login)
{
IActionResult response = Unauthorized();
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!_userService.IsValidUserCredentials(login.UserName, login.Password))
{
return(Unauthorized());
}
var claims = new[]
{
new Claim("username", login.UserName),
new Claim("userid", Convert.ToString(login.UserId))
};
var jwtResult = _jwtAuthManager.GenerateTokens(login.UserName, claims, DateTime.Now);
_loggerService.Info("User:"******"logged in the system.");
return(Ok(new
{
UserName = login.UserName,
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
}));
}
catch (Exception ex)
{
_loggerService.Error(ex);
return(BadRequest());
}
}
public ActionResult Login([FromBody] LoginRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
// if (!_userService.IsValidUserCredentials(request.UserName, request.Password))
// {
// return Unauthorized();
// }
var user = _userManager.FindByNameAsync(request.UserName).Result;
if (!_userManager.CheckPasswordAsync(user, request.Password).Result)
{
return(Unauthorized());
}
// var role = _userService.GetUserRole(request.UserName);
var claims = new[]
{
new Claim(ClaimTypes.Name, user.UserName),
new Claim(ClaimTypes.NameIdentifier, user.Id)
};
var jwtResult = _jwtAuthManager.GenerateTokens(request.UserName, claims, DateTime.Now);
_logger.LogInformation($"User [{request.UserName}] logged in the system.");
return(Ok(new LoginResult
{
UserName = request.UserName,
Role = "admin",
AccessToken = jwtResult.AccessToken,
RefreshToken = jwtResult.RefreshToken.TokenString
}));
}