public async Task <IActionResult> SigIn([FromBody] UserLoginInputModel inputModel)
{
var user = await this.userManager.Users.SingleOrDefaultAsync(u => u.UserName.Equals(inputModel.Username));
var cansSignIn = user is not null && await this.signInManager.CanSignInAsync(user);
var userSignInResult = await this.userManager.CheckPasswordAsync(user, inputModel.Password);
if (user is null || !userSignInResult || !cansSignIn)
{
var error = new ApiErrorModel()
{
Code = nameof(user),
Description = ApiMessagesConstants.InvalidCredentials,
};
return(this.BadRequest(new List <ApiErrorModel> {
error
}));
}
var roles = await this.userManager.GetRolesAsync(user);
var response = this.mapper.Map <UserResponseModel>(user);
response.Token = this.authService.GenerateJwt(user, roles);
return(this.Ok(response));
}
public ApplicationUser Login(UserLoginInputModel input)
{
var hashedPassword = this.utilitiesService.HashPassword(input.Password);
return(this.dbContext.Users
.FirstOrDefault(u => u.Email == input.Email && u.Password == hashedPassword));
}
public async Task <IActionResult> Login(UserLoginInputModel input)
{
var response = new ResponseModel();
if (!ModelState.IsValid)
{
var errorMessage = this.utilitiesService.GetModelStateErorrs(ModelState);
foreach (var message in errorMessage)
{
response.AddErrorMessage(message);
}
response.StatusCode = 400;
return(Json(response));
}
var user = this.usersService.Login(input);
if (user == null)
{
response.AddErrorMessage("Invalid login information");
response.StatusCode = 401;
return(Json(response));
}
var tokens = await this.tokenAuthService.GenerateTokensAsync(user);
response.Data = tokens;
return(Json(response));
}
public async Task <IActionResult> LoginAsync(UserLoginInputModel model)
{
var user = await _userRepository.GetUserByEmailAsync(model.Email);
if (user == null)
{
return(BadRequest(new { message = "Username or Password is incorrect." }));
}
var authenticatedUser = _userRepository.AuthenticateAsync(user, model.Password);
if (authenticatedUser == null)
{
return(BadRequest(new { message = "Email or Password is incorrect." }));
}
var token = GenerateToken(authenticatedUser);
var userLoginOutputModel = new UserLoginOutputModel()
{
UserId = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
Token = token
};
return(Ok(userLoginOutputModel));
}
public async Task <IActionResult> LoginUserAsync([FromBody] UserLoginInputModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ApiError(400, HttpStatusCode.BadRequest.ToString(), "Email/Password are required.")));
}
var userByEmail = await _userRepository.GetUserByEmailAsync(model.Email);
if (userByEmail == null)
{
return(NotFound(new ApiError(400, HttpStatusCode.NotFound.ToString(), "Email wasn't found.")));
}
if (!_userRepository.IsAuthenticatedUser(userByEmail, model.Password))
{
return(BadRequest(new ApiError(400, HttpStatusCode.BadRequest.ToString(), "Email or password is incorrect")));
}
var userOutputModel = Mapper.Map <UserOutputModel>(userByEmail);
userOutputModel.Token = GenerateToken(userByEmail);
return(Ok(userOutputModel));
}
public async Task <IActionResult> Authenticate([FromBody] UserLoginInputModel model)
{
var response = await _userAuthService.Authenticate(model);
if (response == null)
{
return(BadRequest(response));
}
return(Ok(response));
}
public IActionResult Login(UserLoginInputModel model)
{
User userFromDb = this.userService.GetUserByUsernameAndPassword(model.Username, this.HashPassword(model.Password));
if (userFromDb == null)
{
return(this.Redirect("/Users/Login"));
}
this.SignIn(userFromDb.Id, userFromDb.Username, userFromDb.Email);
return(this.Redirect("/"));
}
public async Task <UserAuthResponse> Authenticate(UserLoginInputModel model)
{
var user = await userComponent.GetUser(model.Username, model.Password);
// return null if user not found
if (user != null && user.Id != Guid.Empty)
{
var token = generateJwtToken(user);
return(new UserAuthResponse(user, token));
}
return(null);
}
public HttpResponse Login(UserLoginInputModel input)
{
var userId = this.usersService.GetUserId(input.Username, input.Password);
if (userId != null)
{
this.SignIn(userId);
return(this.Redirect("/Trips/All"));
}
return(this.Redirect("/Users/Login"));
}
public HttpResponse Login(UserLoginInputModel model)
{
var userId = this.usersService.GetId(model.Username, model.Password);
if (userId == null)
{
return(this.Redirect("/Users/Login"));
}
this.SignIn(userId);
return(this.Redirect("/"));
}
public IActionResult Login(UserLoginInputModel model)
{
var userFromDb = this.service.GetUserByParameters(model.Username, this.HashPassword(model.Password));
if (userFromDb == null)
{
return(this.Redirect("/Users/Login"));
}
this.SignIn(userFromDb.Id, userFromDb.Username, userFromDb.Email);
return(this.Redirect("/Home/IndexLoggedIn"));
}
public HttpResponse Login(UserLoginInputModel model)
{
if (!ModelStateValidator.IsValid(model))
{
return(this.View());
}
var userId = this.userService.GetUserId(model.Username, model.Password);
this.SignIn(userId);
return(this.Redirect("/"));
}
public async Task <ActionResult> Login(UserLoginInputModel userLoginInput)
{
try
{
var tokenResult = await userService.SignInUser(userLoginInput.Email, userLoginInput.Password);
return(this.Ok(new { token = tokenResult }));
}
catch (InvalidOperationException ex)
{
return(this.BadRequest(ex));
}
}
public async Task <IActionResult> Login(UserLoginInputModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest());
}
public async Task <bool> Login(UserLoginInputModel model)
{
this.appDataService.User = await this.httpService.Post <UserResponseModel>("api/users/signIn", model);
if (this.appDataService.User is null)
{
this.appDataService.StateHasChanged();
return(false);
}
await this.localStorageService.SetItem(PresentationConstants.UserKey, this.appDataService.User);
this.appDataService.StateHasChanged();
return(true);
}
public static ValidatorResult ValidateLogin(UserLoginInputModel input)
{
var result = new ValidatorResult();
if (!Validator.ValidateEmail(input.Email))
{
result.AddErrorMessage("Invalid email");
}
if (!Validator.ValidatePassword(input.Password))
{
result.AddErrorMessage("Invalid password");
}
return(result);
}
public async Task <IActionResult> Login(UserLoginInputModel input)
{
if (!ModelState.IsValid)
{
return(View());
}
var loginResult = await this.signInManager.PasswordSignInAsync(input.Email, input.Password, input.RememberMe, false);
if (!loginResult.Succeeded)
{
ModelState.AddModelError("Invalid login attempt", "Invalid email or password");
return(View());
}
return(Redirect("/Channel/Index"));
}
public IActionResult Login(UserLoginInputModel input)
{
if (!this.ModelState.IsValid)
{
return(this.Redirect("/Users/Login"));
}
var user = this.usersService.GetUser(input.Username, input.Password);
if (user == null)
{
return(this.Redirect("/Users/Login"));
}
this.SignIn(user.Id, user.Username, user.Email);
return(this.Redirect("/"));
}
public IActionResult Login(UserLoginInputModel model)
{
if (!ModelState.IsValid)
{
return(this.Redirect("/Users/Login"));
}
var userFromDb = this.usersService.GetUserByUsernameAndPassword(model.Username, model.Password);
if (userFromDb == null)
{
return(this.Redirect("/Users/Login"));
}
this.SignIn(userFromDb.Id, userFromDb.Username, userFromDb.Password);
return(this.Redirect("/"));
}
public IActionResult Login(UserLoginInputModel model)
{
if (!ModelState.IsValid)
{
return(this.Redirect("/Users/Login"));
}
User user = this.userService.GetUserByUsernameAndPassword(model.Username, this.HashPassword(model.Password));
if (user == null)
{
return(this.Redirect("/Users/Login"));
}
this.SignIn(user.Id, user.Username, user.Email);
return(this.Redirect("/"));
}
public HttpResponse Login(UserLoginInputModel inputModel)
{
if (this.IsUserLoggedIn())
{
return(this.Redirect("/"));
}
var userId = this.usersService.GetId(inputModel.Username, inputModel.Password);
if (userId == null)
{
return(this.Redirect("/Users/Login"));
}
this.SignIn(userId);
return(this.Redirect("/Trips/All"));
}
public async Task <IActionResult> Login(UserLoginInputModel input)
{
if (this.ModelState.IsValid == false)
{
return(this.View(input));
}
var user = this.usersService.GetBy(input.Username, input.Password);
if (user == null)
{
this.TempData["InvalidLogin"] = "******";
return(this.View(input));
}
await this.signInManager.SignInAsync(user, input.IsPersistent);
return(this.Redirect("/Contragents/All"));
}
public IActionResult Login(UserLoginInputModel inputModel)
{
if (!this.ModelState.IsValid)
{
return(this.Redirect("/User/Login"));
}
var user = this.context
.Users
.FirstOrDefault(u => u.PasswordHash == inputModel.Password && u.UserName == inputModel.Username);
if (user is null)
{
return(this.Redirect("/User/Login"));
}
return(this.Redirect("/Home/Index"));
}
public UserLoginInputModel Login([FromBody] UserLoginInputModel model)
{
return(model);
}
public IActionResult Login()
{
var emptyUserLoginInputModel = new UserLoginInputModel();
return(this.View(emptyUserLoginInputModel));
}
