public IActionResult Login(UserLoginBindingModel model)
{
if (this.User.IsAuthenticated)
{
return(this.RedirectToHome());
}
if (!this.IsValidModel(model))
{
return(this.BuildErrorView());
}
User user;
using (this.Context)
{
user = this.Context
.Users
.FirstOrDefault(u => u.Username == model.Username);
}
var passwordHash = PasswordUtilities.GetPasswordHash(model.Password);
if (passwordHash != user.PasswordHash)
{
return(this.BuildErrorView());
}
this.SignIn(user.Username, user.Id);
return(this.RedirectToHome());
}
[ProducesResponseType(500)] //If there was an internal server error
public async Task <IActionResult> AuthenticateUserAsync([FromBody] UserLoginBindingModel userLoginBindingModel)
{
var response = new SingleResponse <dynamic>();
var user = this._mapper.Map <User>(userLoginBindingModel);
var userAuthenticationDetails = await this._authenticationService.AuthenticateUserAsync(user);
var userAuthentication = userAuthenticationDetails.Item2;
var userDetails = userAuthenticationDetails.Item1;
UserAuthenticationBindingModel userAuthenticationBindingModel = new UserAuthenticationBindingModel();
userAuthenticationBindingModel = this._mapper.Map <UserAuthenticationBindingModel>(userAuthentication);
userAuthenticationBindingModel.UserName = userLoginBindingModel.UserName;
if (userAuthenticationBindingModel.IsUserAuthenticated)
{
response.Message = "User " + userAuthentication.UserName
+ " authenticated successfully. Redirecting to Home screen.";
this.CreateJWTToken(response, userAuthenticationBindingModel);
}
else
{
response.Model = userAuthenticationBindingModel;
response.DidValidationError = true;
response.Message = "User Name or Password is Incorrect. Please try again";
}
return(response.ToHttpResponse());
}
public IActionResult Login(string returnUrl = "")
{
var model = new UserLoginBindingModel {
ReturnUrl = returnUrl
};
return(this.View(model));
}
internal User GetCurrentUser(UserLoginBindingModel bindingModel)
{
User user = this.context.Users
.FirstOrDefault(u => u.Email == bindingModel.LoginEmail &&
u.Password == bindingModel.LoginPassword);
return(user);
}
public IActionResult Login([FromBody] UserLoginBindingModel user)
{
var token = this.usersService.Login(user.Username, user.Password);
if (token is null)
{
return(BadRequest(new { message = "Invalid Credentials!" }));
}
return(Ok(new { token = token, isAdmin = this.usersService.IsAdmin(token), name = user.Username, message = "Login successful!" }));
}
public IActionResult Login(UserLoginBindingModel model)
{
User userFromDb = this.usersService.ReturnUserByData(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("/");
}
internal bool IsValidLoginInput(UserLoginBindingModel bindingModel)
{
if (string.IsNullOrEmpty(bindingModel.LoginEmail) ||
string.IsNullOrEmpty(bindingModel.LoginPassword))
{
return(false);
}
return(true);
}
public bool LogUserIn(HttpSession session, UserLoginBindingModel ulbm)
{
var user = this.data.Users.FindByPredicate(u => u.Email == ulbm.Email && u.Password == ulbm.Password);
if (user != null)
{
this.CreateLoginForUser(session, user);
this.data.SaveChanges();
return(true);
}
return(false);
}
internal void LoginUser(UserLoginBindingModel bindingModel, User currentUser, HttpSession currentSession)
{
Login login = new Login()
{
SessionId = currentSession.Id,
User = currentUser,
IsActive = true
};
this.context.Logins.Add(login);
this.context.SaveChanges();
}
public async Task <IActionResult> Login([FromBody] UserLoginBindingModel model)
{
var user = await userManager.FindByEmailAsync(model.Email);
var result = signInManager.PasswordSignInAsync(user, model.Password, true, false).Result;
if (result.Succeeded)
{
return(this.Ok());
}
return(this.BadRequest(result.IsNotAllowed));
}
public HttpResponse Login(UserLoginBindingModel model)
{
var user = this.userService.GetUser(model.Username, model.Password);
if (user == null)
{
return(this.Redirect("/Users/Login"));
}
this.SignIn(user.Id);
return(this.Redirect("/"));
}
public async Task <IActionResult> LoginNextStep([FromBody] UserLoginBindingModel collection)
{
if (string.IsNullOrWhiteSpace(collection?.DeviceId))
{
return(BadRequest(GeneralMessage.DeviceIdNotFound));
}
if (string.IsNullOrWhiteSpace(collection?.UserName) && string.IsNullOrWhiteSpace(collection?.Phone) && string.IsNullOrWhiteSpace(collection?.Email))
{
return(BadRequest(GeneralMessage.DefectiveEntry));
}
if (string.IsNullOrWhiteSpace(collection?.Password))
{
return(BadRequest("گذرواژه را وارد نمایید"));
}
try {
var model = _mapper.Map <UserNextStepLoginSchema>(collection);
await _userService.LoginAsync(model);
switch (model.StatusCode)
{
case 1:
return(Ok(data: new { model.Token }));
case 2:
return(Ok(status: HttpStatusCode.Accepted, message: "اعتبار سنجی دو مرحله ای فعال می باشد"));
case -1:
return(BadRequest(GeneralMessage.DefectiveEntry));
case -2:
return(BadRequest("نام کاربری یا گذرواژه شما اشتباه است"));
case -3:
return(BadRequest("تلفن یا گذرواژه شما اشتباه است"));
case -4:
return(BadRequest("ایمیل یا گذرواژه شما اشتباه است"));
case -5:
return(BadRequest(GeneralMessage.DeviceIdNotFound));
case -6:
return(BadRequest("شما ابتدا می بایست با کد فعال ساز اقدام به ورود نمایید"));
}
}
catch (Exception ex) {
await _exceptionService.InsertAsync(ex, URL, IP);
}
return(InternalServerError());
}
public IActionResult LogIn(UserLoginBindingModel model)
{
if (ModelState.IsValid)
{
var user = _userService.GetAll().FirstOrDefault(u => u.Login == model.Login &&
u.Password == model.Password);
if (user != null)
{
Authenticate(user); // аутентификация
return(RedirectToAction("Products", "Store"));
}
ModelState.AddModelError("", "Некорректные логин и(или) пароль");
}
return(View(model));
}
public IActionResult Login(UserLoginBindingModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (this.users.Exists(model.Username, model.Password))
{
this.ModelState.AddModelError("username", "User already exists!");
return(View(model));
}
this.HttpContext.Session.SetString(UserSessionKey, model.Username);
return(RedirectToPage("/Index"));
}
public async Task <IActionResult> Login(UserLoginBindingModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
var user = await this.accountsServices.LoginUserAsync(model);
if (user == null)
{
this.ViewData["Errors"] = GlobalConstants.InvalidLoginMessage;
return(this.View());
}
return(this.Redirect(GlobalConstants.Index));
}
public IActionResult Login(UserLoginBindingModel model)
{
if (!this.IsValidModel(model))
{
this.Model.Data["error"] = "Invalid username and/or password";
if (string.IsNullOrWhiteSpace(model.Username))
{
this.Model.Data["error"] = "Username is required";
}
else if (string.IsNullOrWhiteSpace(model.Password))
{
this.Model.Data["error"] = "Password is required";
}
return(this.View());
}
if (this.User.IsAuthenticated)
{
return(this.RedirectToHome());
}
using (this.Context)
{
var user = this.Context.Users.FirstOrDefault(u => u.Username == model.Username);
if (user == null)
{
this.Model.Data["error"] = "Invalid username and/or password";
return(this.View());
}
var passwordHash = PasswordUtilities.GetPasswordHash(model.Password);
if (user.Password != passwordHash)
{
this.Model.Data["error"] = "Invalid username and/or password";
return(this.View());
}
this.SignIn(user.Username, user.Id);
}
return(RedirectToHome());
}
public IActionResult Login(UserLoginBindingModel model)
{
if (!ModelState.IsValid)
{
return(this.Redirect("/Users/Login"));
}
var user = this.usersService.GetUserByUsernameAndPassword(model.Username, model.Password);
if (user == null)
{
return(this.Redirect("/Users/Login"));
}
this.SignIn(user.Id, user.Username, user.Email);
return(this.Redirect("/"));
}
public IActionResult Login(UserLoginBindingModel model)
{
if (this.IsLoggedIn())
{
return(this.Redirect("/"));
}
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 IActionResult Login(HttpSession session, HttpResponse response, UserLoginBindingModel ulbm)
{
if (this.service.IsUserLoggedInOrRegistered(session))
{
this.Redirect(response, "/home/index");
return null;
}
bool successfulLogin = this.service.LogUserIn(session, ulbm);
if (successfulLogin)
{
this.Redirect(response, "/home/index");
return null;
}
this.Redirect(response, "/users/login");
return null;
}
public IActionResult Login(UserLoginBindingModel model)
{
if (!this.ModelState.IsValid)
{
return(this.Redirect("/Users/Register"));
}
var userId = this.userService.GetUserOrNull(model.Username, model.Password);
if (userId == null)
{
return(this.Redirect("/Users/Login"));
}
this.SignIn(userId.Id.ToString(), model.Username, model.Password);
return(Redirect("/"));
}
public UserModel GetUser(UserLoginBindingModel userModel)
{
using (this.userRepository)
{
UserWithPasswordModel userWithPassword = this.userRepository.GetUserWithPasswordByUsername(userModel.Username);
if (userWithPassword == null)
{
return(null);
}
string actualPasswordHash = PasswordUtilities.GeneratePasswordHash(userModel.Password, userWithPassword.PasswordSalt);
if (actualPasswordHash != userWithPassword.PasswordHash)
{
return(null);
}
UserModel user = new UserModel(userWithPassword.Id, userWithPassword.Username);
return(user);
}
}
public IActionResult Login(UserLoginBindingModel model)
{
if (!this.ModelState.IsValid)
{
return(this.Redirect("/Users/Login"));
}
var hashedPassword = this.HashPassword(model.Password);
var userFromDb = this.userService.GetUserByUsernameAndPassword(model.Username, hashedPassword);
if (userFromDb == null)
{
return(this.Redirect("/Users/Login"));
}
this.SignIn(userFromDb.Id, userFromDb.Username, userFromDb.Email);
return(this.Redirect("/"));
}
public IActionResult Login(UserLoginBindingModel bindingModel, HttpResponse response, HttpSession currentSession)
{
if (this.loginManager.IsAuthenticated(currentSession))
{
this.Redirect(response, "/users/feed");
return(null);
}
if (!this.userService.IsValidLoginInput(bindingModel))
{
this.Redirect(response, "/users/login");
return(null);
}
User currentUser = this.userService.GetCurrentUser(bindingModel);
this.userService.LoginUser(bindingModel, currentUser, currentSession);
this.Redirect(response, "/users/feed");
return(null);
}
public ActionResult Login(UserLoginBindingModel userModel)
{
if (!this.ModelState.IsValid)
{
return(this.View(userModel));
}
UserModel user = this.userManager.GetUser(userModel);
if (user == null)
{
this.TempData.AddErrorMessage(MessageConstants.InvalidCredentials);
return(this.View(userModel));
}
this.Session[AuthConstants.SessionUserKey] = user;
this.TempData.AddSuccessMessage(MessageConstants.LoginSuccessful);
return(this.RedirectToAction(nameof(AccountsController.Index), WebConstants.AccountsController));
}
public async Task <IActionResult> Login(UserLoginBindingModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
var result = await this.signInManager.PasswordSignInAsync(model.Username, model.Password, model.RememberMe, false);
if (result.Succeeded)
{
if (!string.IsNullOrEmpty(returnUrl))
{
return(LocalRedirect(returnUrl));
}
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "Invalid Login attempt!");
}
return(View(model));
}
public async Task <IHttpActionResult> Login(UserLoginBindingModel loginInfo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await UserManager.FindByNameAsync(loginInfo.Email);
if (user == null)
{
return(Ok("Email not found!"));
}
SignInStatus result = await SignInManager.PasswordSignInAsync(loginInfo.Email, loginInfo.Password, false, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
FormsAuthentication.SetAuthCookie(loginInfo.Email, true);
// reset request.isauthenticated
var authCookie = System.Web.HttpContext.Current.Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
if (authTicket != null && !authTicket.Expired)
{
var roles = authTicket.UserData.Split(',');
System.Web.HttpContext.Current.User = new System.Security.Principal.GenericPrincipal(new FormsIdentity(authTicket), roles);
}
}
return(Ok());
case SignInStatus.Failure:
return(Ok("Invalid password for username " + loginInfo.Email + "!"));
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(Ok(loginInfo));
}
}
public IHttpActionResult UserLogin(UserLoginBindingModel login)
{
using (var ctx = new testEntities())
{
var existingUser = ctx.users
.Where(x => x.EMAIL == login.Email && x.PASSWORD == login.Password)
.FirstOrDefault <user>();
if (existingUser != null)
{
existingUser.LAST_LOGIN = DateTime.Now;
ctx.SaveChanges();
}
else
{
return(NotFound());
}
return(Ok(existingUser));
}
}
public IActionResult Login([FromBody] UserLoginBindingModel model)
{
var response = this.UserServices.Authenticate(model.Email, model.Password, this.HttpContext, out var user);
if (response.Result == UserService.InvalidEmail)
{
this.ModelState.AddModelError(nameof(UserService.InvalidEmail), UserService.InvalidEmail);
return(this.BadRequest(this.ModelState));
}
if (response.Result == UserService.InvalidPassword)
{
this.ModelState.AddModelError(nameof(UserService.InvalidPassword), UserService.InvalidPassword);
return(this.BadRequest(this.ModelState));
}
response.Id = user.Id;
response.FirstName = user.FirstName;
response.LastName = user.LastName;
response.Email = user.Email;
response.AvatarPath = user.AvatarPath;
return(this.Ok(response));
}
public IActionResult Login(UserLoginBindingModel model)
{
if (this.User.IsAuthenticated)
{
return(RedirectToHome());
}
if (!this.IsValidModel(model))
{
this.Model.Data["error"] = this.GetErrorMessageFromInvalidProp(model);
return(this.View());
}
User userDb;
using (this.Context)
{
userDb = this.Context.Users.FirstOrDefault(u => u.Email == model.Email);
}
if (userDb is null)
{
this.Model.Data["error"] = "Invalid username or/and password";
return(this.View());
}
var passwordHash = PasswordUtilities.GetPasswordHash(model.Password);
if (passwordHash != userDb.Password)
{
this.Model.Data["error"] = "Invalid username or/and password";
return(this.View());
}
this.SignIn(userDb.Name, userDb.Id);
return(RedirectToHome());
}
public IActionResult Login(UserLoginBindingModel user)
{
if (this.User.IsAuthenticated)
{
return(RedirectToHome());
}
if (!this.IsValidModel(user))
{
this.Model.Data["error"] = InvalidUsernameOrPasswordMessage;
return(this.View());
}
User userDb;
using (this.Context)
{
userDb = this.Context.Users.Where(u => u.Username == user.Username).FirstOrDefault();
}
if (userDb is null)
{
this.Model.Data["error"] = InvalidUsernameOrPasswordMessage;
return(this.View());
}
var passwordHash = PasswordUtilities.GetPasswordHash(user.Password);
if (passwordHash != userDb.Password)
{
this.Model.Data["error"] = InvalidUsernameOrPasswordMessage;
return(this.View());
}
this.SignIn(userDb.Username);
return(RedirectToHome());
}
