public async Task <RequestResult <UserViewModel> > LoginAsync(LoginUserRequestModel loginModel)
{
var result = new RequestResult <UserViewModel>();
try
{
User user = string.IsNullOrEmpty(loginModel.Email)
? await _userManager.FindByNameAsync(loginModel.Username)
: await _userManager.FindByEmailAsync(loginModel.Email);
if (user == null || !await _userManager.CheckPasswordAsync(user, loginModel.Password))
{
result.Errors = new[] { "Incorrect username or password." };
return(result);
}
var userViewModel = new UserViewModel().SetFrom(user);
userViewModel.Token = GenerateAuthenticationToken(user);
result.Obj = userViewModel;
result.SetStatusOK();
}
catch (Exception ex)
{
result.SetInternalServerError();
_logger.LogException(ex);
}
return(result);
}
public async Task <ActionResult <string> > Login(LoginUserRequestModel loginUserRequestModel)
{
var user = await _userManager.FindByNameAsync(loginUserRequestModel.UserName);
if (user == null)
{
return(Unauthorized());
}
var isPasswordValid = await _userManager.CheckPasswordAsync(user, loginUserRequestModel.Password);
if (!isPasswordValid)
{
return(Unauthorized());
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.Id.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var encryptedToken = tokenHandler.WriteToken(token);
return(encryptedToken);
}
public async Task <Result <LoginModel> > Login(LoginUserRequestModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var user = await this.userManager.FindByNameAsync(model.Username);
if (user == null)
{
return(Result <LoginModel> .Error("Username or password are invalid"));
}
var validationResult = await this.userManager.CheckPasswordAsync(user, model.Password);
if (!validationResult)
{
return(Result <LoginModel> .Error("Username or password are invalid"));
}
return(Result <LoginModel> .Success(
new LoginModel
{
ProfileUrl = user.ProfileUrl,
Token = this.GenerateJwtToken(user),
}));
}
public async Task <IActionResult> Login([FromBody] LoginUserRequestModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, false, false);
if (!result.Succeeded)
{
return(BadRequest("Could not login"));
}
var user = await _userManager.FindByEmailAsync(model.Email);
var token = await BuildToken(user);
return(Ok(token));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult <ResultModel <LoginResponseModel> > > Login(LoginUserRequestModel model)
{
var result = await this.identityService.LoginAsync(model.Username, model.Password, appSettings.Secret);
if (!result.Success)
{
return(this.Unauthorized(new { result.Errors }));
}
return(result);
}
public async Task <ActionResult> Login(LoginUserRequestModel model)
{
var result = await this.identityService.Login(model);
if (result.IfHaveError)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <ActionResult <LoginResponseModel> > Login([FromBody] LoginUserRequestModel model)
{
var user = await _userManager.FindByNameAsync(model.Username);
if (user != null && await _userManager.CheckPasswordAsync(user, model.Password))
{
var response = new LoginResponseModel()
{
Token = _identityEngine.GenerateJwtToken(_appSettings.JwtSecret, user.Id, user.UserName)
};
return(Ok(response));
}
return(Unauthorized());
}
public async Task <ActionResult <TokenResponse> > Login(LoginUserRequestModel model)
{
TokenResponse token;
try
{
token = await _service.LogIn(model);
}
catch (Exception ex)
{
return(Unauthorized(ex.Message));
}
return(token);
}
public IActionResult Login([FromBody] LoginUserRequestModel login)
{
try
{
var token = _authenticationService.Authenticate(login);
return(Ok(new
{
token = token.Item1,
user = token.Item2,
}));
}
catch (AuthenticationException)
{
return(Unauthorized());
}
}
public async Task <TokenResponse> LogIn(LoginUserRequestModel model)
{
LoginResponse result = new();
try
{
result = await _repository.LogIn(model);
}
catch (Exception)
{
throw;
}
var token = GenerateToken(result.ID, result.Username, "this is secret this is secret this is secret this is secret this is secret this is secret this is secret");
return(new TokenResponse {
Token = token
});
}
public async Task <LoginResponse> LogIn(LoginUserRequestModel model)
{
var user = await UserManager.FindByEmailAsync(model.Email);
if (user == default)
{
throw new System.Exception("User was not found");
}
var passwordValid = await UserManager.CheckPasswordAsync(user, model.Password);
if (!passwordValid)
{
throw new System.Exception("password doesnot match");
}
return(new LoginResponse {
Username = user.UserName,
ID = user.Id
});
}
public async Task <ResultModel> Login([FromBody] LoginUserRequestModel requestModel)
{
if (!ModelState.IsValid)
{
return(new ResultModel
{
Message = "Invalid data",
Status = Status.Error,
Data = string.Join("", ModelState.Keys.Select(e => "<li>" + e + "</li>"))
});
}
var user = await userManager.FindByNameAsync(requestModel.UserName);
var checkPw = await userManager.CheckPasswordAsync(user, requestModel.Password);
if (user != null && checkPw)
{
var identity = new ClaimsIdentity(CookieAuthenticationDefaults.AuthenticationScheme);
identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.ID));
identity.AddClaim(new Claim(ClaimTypes.Name, user.UserName));
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(identity));
return(new ResultModel
{
Status = Status.Success,
Message = "Succesfull login",
Data = requestModel
});
}
else
{
return(new ResultModel
{
Status = Status.Error,
Message = "Invalid data",
Data = "<li>Invalid Username or Password</li>"
});
}
}
public async Task <ActionResult <object> > Login(LoginUserRequestModel model)
{
User user = await this.userManager.FindByNameAsync(model.Username);
if (user == null)
{
return(Unauthorized());
}
bool passwordValid = await this.userManager.CheckPasswordAsync(user, model.Password);
if (!passwordValid)
{
return(Unauthorized());
}
return(new
{
Token = this.identityService.GenerateJwtToken(user, this.appSettings.Secret)
});
}
public async Task <ActionResult <string> > Login(LoginUserRequestModel model)
{
using (var transaction = _dbContext.Database.BeginTransaction())
{
if (model.Password == null)
{
return(BadRequest(new { message = "Bad data" }));
}
if (model.Password.Length < 6)
{
return(BadRequest(new { message = "Bad data" }));
}
var user = await this.userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(Unauthorized("Email is not registered!"));
}
//KOMENTARISATI KAKO BI SE ULOGOVALi
//var isEmailConfirmed = await this.userManager.IsEmailConfirmedAsync(user);
//if (!isEmailConfirmed)
//{
// return Unauthorized("Email is not confirmed!");
//}
var passwordValid = await this.userManager.CheckPasswordAsync(user, model.Password);
if (!passwordValid)
{
return(Unauthorized("Wrong password!"));
}
var token = generateJwtToken(user);
transaction.Commit();
return(Ok(new { token }));
}
}
public ActionResult <CommonResponeModel> Login(LoginUserRequestModel model)
{
var LoginResponeModel = new LoginResponeModel();
//login success
if (userRepository.IsValidUser(model.Username, model.Password))
{
Result = new SuccessResultFactory().Factory(ActionType.Login);
LoginResponeModel.TokenExpireDate = DateTime.Now.AddDays(1);
LoginResponeModel.Token = TokenProvider.GenerateTokenString(model.ToDictionaryStringString());
LoginResponeModel.User = userRepository.GetDataTransferByUsername(model.Username);
}
else //login fail
{
Result = new ErrorResultFactory().Factory(ActionType.Login);
}
//set data
Data = LoginResponeModel;
return(GetCommonRespone());
}
public async Task <IActionResult> Login(LoginUserRequestModel model)
{
var user = await userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(Unauthorized());
}
var passwordValid = await userManager.CheckPasswordAsync(user, model.Password);
if (!passwordValid)
{
return(Unauthorized());
}
var result = new LoginResponseModel
{
Token = identityService.GenerateJwtToken(user, appSettings.Secret)
};
return(Ok(result));
}
public async Task <RequestResult> LoginAsync(LoginUserRequestModel loginUser)
{
return(await _userService.LoginAsync(loginUser));
}
