public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!this.ModelState.IsValid)
{
return this.View(model);
}
if (model.Email.Contains("@"))
{
var user = this.UserManager.FindByEmail(model.Email);
if (user != null)
{
model.Email = user.UserName;
}
}
var result = await this.SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
switch (result)
{
case SignInStatus.Success:
return this.RedirectToLocal(returnUrl);
case SignInStatus.LockedOut:
return this.View("Lockout");
case SignInStatus.RequiresVerification:
return this.RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
case SignInStatus.Failure:
default:
this.ModelState.AddModelError(string.Empty, "Invalid login attempt.");
return this.View(model);
}
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
try
{
var user = await UserManager.FindAsync(model.Email, model.Password);
if (user != null)
{
await SignInAsync(user, model.RememberMe);
return Json(new { success = true, url = returnUrl });
}
else
{
ModelState.AddModelError("", "Invalid username or password.");
}
//await experiment(user);
}
catch (DbEntityValidationException dbx)
{
foreach(var item in dbx.EntityValidationErrors)
{
foreach(var thisThing in item.ValidationErrors)
{
Trace.TraceInformation("Property: {0} Error: {1}", thisThing.PropertyName, thisThing.ErrorMessage);
}
}
}
}
return PartialView(model);
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!this.ModelState.IsValid)
{
return this.View(model);
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result =
await this.SignInManager.PasswordSignInAsync(model.Username, model.Password, model.RememberMe, false);
switch (result)
{
case SignInStatus.Success:
return this.RedirectToLocal(returnUrl);
case SignInStatus.LockedOut:
return this.View("Lockout");
case SignInStatus.RequiresVerification:
return this.RedirectToAction("SendCode", new { ReturnUrl = returnUrl, model.RememberMe });
case SignInStatus.Failure:
default:
this.ModelState.AddModelError("", "Invalid login attempt.");
return this.View(model);
}
}
public async Task<ActionResult> SignIn(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
//return PartialView("_Login", model);
//return PartialView();
return View("Error");
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
switch (result)
{
case SignInStatus.Success:
var user = await UserManager.FindAsync(model.Email, model.Password);
await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
return RedirectToLocal(returnUrl);
case SignInStatus.LockedOut:
return View("Lockout");
case SignInStatus.RequiresVerification:
return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
//return RedirectToAction("Index", "Home");
//return View("_LoginPartial");
//return PartialView("_Login",model);
return View("Error");
}
}
public LoginView() : base()
{
loginViewModel = new LoginViewModel();
BindingContext = loginViewModel;
InitializeComponent();
NavigationPage.SetHasNavigationBar(this, false);
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
//if (ModelState.IsValid)
//{
// var user = await UserManager.FindAsync(model.UserName, model.Password);
// if (user != null)
// {
// MigrateShoppingCart(model.UserName);
// await SignInAsync(user, model.RememberMe);
// return RedirectToLocal(returnUrl);
// }
// else
// {
// ModelState.AddModelError("", "Invalid username or password.");
// }
//}
//// If we got this far, something failed, redisplay form
//return View(model);
var result = PasswordSignIn(model.UserName, model.Password, model.RememberMe, shouldLockout: APPLY_USER_LOCKOUT);
switch (result)
{
case SignInStatus.Success:
return RedirectToLocal(returnUrl);
case SignInStatus.LockedOut:
ModelState.AddModelError("", "Account is locked");
return View(model);
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid atempt");
return View(model);
}
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindAsync(model.UserName, model.Password);
if (user != null)
{
var identity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
identity.AddClaim(new Claim("FirstName", user.FirstName));
identity.AddClaim(new Claim("LastName", user.LastName));
identity.AddClaim(new Claim("Email", user.Email));
identity.AddClaim(new Claim("Role", user.role.ToString()));
await SignInAsync(user, model.RememberMe);
return RedirectToLocal(returnUrl);
}
else
{
ModelState.AddModelError("", "Invalid username or password.");
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Main(string LID)
{
if (LID != null)
{
var db = getDB0();
var getItem = db.Apply_User.Where(x => x.userid == LID).FirstOrDefault();
if (getItem != null)
{
LoginViewModel md = new LoginViewModel() { account = "user", password = "******", lang = "zh-TW", rememberme = false };
var getResult = await ajax_Login(md);
LoginResult trnResult = Newtonsoft.Json.JsonConvert.DeserializeObject<LoginResult>(getResult);
if (trnResult.result)
{
Response.Cookies.Add(new HttpCookie("user_id", Server.UrlEncode(EncryptString.desEncryptBase64(getItem.userid))));
Response.Cookies.Add(new HttpCookie("user_name", Server.UrlEncode(getItem.username)));
Response.Cookies.Add(new HttpCookie("user_login", Server.UrlEncode(EncryptString.desEncryptBase64("Y"))));
return Redirect(trnResult.url + "/Users");
}
}
}
HttpContext.GetOwinContext().Authentication.SignOut();
ViewData["username"] = "";
ViewData["password"] = "";
#if DEBUG
ViewData["username"] = CommWebSetup.AutoLoginUser;
ViewData["password"] = CommWebSetup.AutoLoginPassword;
#endif
return View("Index");
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
// var user = new ApplicationUser { UserName = "******", Email = "*****@*****.**" };
// var re = await UserManager.CreateAsync(user, "Abc@123456");
if (!ModelState.IsValid)
{
return View(model);
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
switch (result)
{
case SignInStatus.Success:
return RedirectToLocal(returnUrl);
case SignInStatus.LockedOut:
return View("Lockout");
case SignInStatus.RequiresVerification:
return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return View(model);
}
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return View(model);
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result =
await SignInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, false);
switch (result)
{
case SignInStatus.Success:
//var hubContext = GlobalHost.ConnectionManager.GetHubContext<BaseHub>();
var user = await UserManager.FindAsync(model.UserName, model.Password);
//hubContext.Clients.AllExcept(user.UserName).kur("qjhui");
if (UserManager.IsInRole(user.Id, "Administrator"))
{
return RedirectToAction("Index", "Home");
}
return RedirectToLocal(returnUrl);
case SignInStatus.LockedOut:
return View("Lockout");
case SignInStatus.RequiresVerification:
return RedirectToAction("SendCode", new {ReturnUrl = returnUrl, model.RememberMe});
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return View(model);
}
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return View(model);
}
var user = _db.Users.FirstOrDefault(x => x.Email == model.Email && x.Password == model.Password);
if(user==null)
return View("Lockout");
// Если нельзя заходить - то всё, заблокирован
if (!ValidateUser(user))
{
string text = user.BlockReason;
text += "\nДата окончания блокировки: ";
text += user.BlockForDate;
text += "\nЕсли причина блокировки неясна, то - отпишите нам, пожалуйста, по кнопке в правом нижнем углу. С уважением, администрация GarageInc";
return Content(text);
}
var result = SignInManager.PasswordSignIn(model.Email, model.Password, model.RememberMe, shouldLockout: false);
switch (result)
{
case SignInStatus.Success:
{
if (user != null)
{
using (var transaction = _db.Database.BeginTransaction())
{
try
{
user.LastVisition = DateTime.Now;
_db.Entry(user).State = EntityState.Modified;
_db.SaveChanges();
transaction.Commit();
}
catch (Exception error)
{
transaction.Rollback();
return PartialView("_Content", error.Message);
}
}
}
return RedirectToLocal(returnUrl);
}
case SignInStatus.LockedOut:
return View("Lockout");
case SignInStatus.RequiresVerification:
return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Неудачная попытка входа.");
return View(model);
}
}
public ActionResult LogIn(LoginViewModel model)
{
if (ModelState.IsValid)
{
bool temp = true;
try
{
temp = model.Email == "*****@*****.**";
temp = model.Password == "123";
temp = Membership.ValidateUser(model.Email, model.Password);
}
catch (Exception e)
{
System.Console.WriteLine("Error");
}
return RedirectToAction("Index", "Home");
}
return RedirectToAction("LogIn", "Account");
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return View(model);
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
switch (result)
{
case SignInStatus.Success:
{
var visitor = new Visitor();
var userTemp = db.Users.FirstOrDefault(x => x.Email == model.Email);
visitor.UserId = userTemp.Id;
visitor.Time = DateTime.Now.ToString();
visitor.VisitorIP = GetIPAdress(Request);
visitor.VisitorCountry = "";// await GetCountryFromIp(visitor.VisitorIP);
myContext.Visitors.Add(visitor);
myContext.Entry(visitor).State = System.Data.Entity.EntityState.Added;
myContext.SaveChanges();
return RedirectToLocal(returnUrl);
}
case SignInStatus.LockedOut:
return View("Lockout");
case SignInStatus.RequiresVerification:
return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return View(model);
}
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindAsync(model.UserName, model.Password);
//zaatar - to handle the diable login
if (!userLogic.CanLogin(model.UserName))
{
ModelState.AddModelError("", "You cannot login. Your acount is disabled by the administrator.");
return View(model);
}
//end zaatar
if (user != null)
{
await SignInAsync(user, model.RememberMe);
return RedirectToLocal(returnUrl);
}
else
{
ModelState.AddModelError("", "Invalid username or password.");
}
}
return View(model);
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return View(model);
}
// Require the user to have a confirmed email before they can log on.
var user = await UserManager.FindByNameAsync(model.Email);
if (user != null)
{
if (!await UserManager.IsEmailConfirmedAsync(user.Id))
{
ViewBag.errorMessage = "You must have a confirmed email to log on.";
return View("Error");
}
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
switch (result)
{
case SignInStatus.Success:
return RedirectToLocal(returnUrl);
case SignInStatus.LockedOut:
return View("Lockout");
case SignInStatus.RequiresVerification:
return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return View(model);
}
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindAsync(model.UserName, model.Password);
if (user != null)
{
await SignInAsync(user, model.RememberMe);
var db = new CMISProject.DAL.CIMSEntities();
if (db.Admins.Where(s => s.AdminName == model.UserName).Count() == 1)
{
HttpContext.Session["isAdmin"] = true;
HttpContext.Session["UserId"] = db.Admins.Single(s => s.AdminName == model.UserName).AdminId;
}
else if( db.Users.Where(s => s.UserName == model.UserName).Count()==1)
{
HttpContext.Session["isAdmin"] = false;
HttpContext.Session["UserId"] = db.Users.Single(s => s.UserName == model.UserName).UserId;
}
HttpContext.Session["Username"] = model.UserName;
return RedirectToLocal(returnUrl);
}
else
{
ModelState.AddModelError("", "Invalid username or password.");
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
{
EnsureDatabaseCreated(_applicationDbContext);
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, set lockoutOnFailure: true
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: false);
if (result.Succeeded)
{
return RedirectToLocal(returnUrl);
}
if (result.RequiresTwoFactor)
{
return RedirectToAction(nameof(SendCode), new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
}
if (result.IsLockedOut)
{
return View("Lockout");
}
else
{
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
return View(model);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public ActionResult Logar(LoginViewModel model)
{
if (!ModelState.IsValid)
{
return View("Index", model);
}
AutenticacaoService service = new AutenticacaoService();
Stopwatch sw = Stopwatch.StartNew();
bool resultado = service.Autenticar(model.Usuario, model.Senha);
sw.Stop();
Trace.WriteLine("Autenticar em " + sw.ElapsedMilliseconds);
if (!resultado)
{
ModelState.AddModelError("Usuario",
"Usuário ou senha inválidos");
return View("Index", model);
}
return Content("TOP SECRET!");
}
public string GetUserDetails(string userName)
{
string isCaptchaDisplay = null;
var loginType = CheckInputType(userName);
var loginViewModel = new LoginViewModel();
var user = _wcfService.InvokeService<IUserService, User>(svc => svc.GetUserByUsername(userName, loginType));
if (user != null)
{
var ipAddress = GetClientIpAddress();
var userHistory = user.UserLogins.Select(x => x.UserHistories.FirstOrDefault(y => y.IpAddress == ipAddress)).ToList();
if (userHistory == null)
{
isCaptchaDisplay = "False";
loginViewModel.IsCaptchaDisplay = isCaptchaDisplay.AsBool();
return isCaptchaDisplay;
}
else
{
isCaptchaDisplay = "True";
loginViewModel.IsCaptchaDisplay = isCaptchaDisplay.AsBool();
return isCaptchaDisplay;
}
}
//ModelState.AddModelError("UserName", "The user name is not correct.");
return isCaptchaDisplay;
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindAsync(model.UserName, model.Password);
// // Insert a new user into the database
//using (var db = new ApplicationDbContext())
//{
// db.Results.Add(new Result { TeamName = model.} )
//}
if (user != null)
{
await SignInAsync(user, model.RememberMe);
return RedirectToLocal(returnUrl);
}
else
{
ModelState.AddModelError("", "Invalid username or password.");
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindAsync(model.UserName, model.Password);
if (user != null)
{
// Put in the session the logged user.
Session["user"] = user;
TempData["userName"] = user.UserName;
// Define if the user is Administrator. If not I need go get his ID to use in the query.
if (user.UserName.Equals("Admin"))
TempData["userId"] = null;
else
TempData["userId"] = user.Id;
TempData.Keep();
await SignInAsync(user, model.RememberMe);
return RedirectToLocal(returnUrl);
}
else
ModelState.AddModelError(string.Empty, "The User Name and/or Password entered is invalid. Please try again.");
}
// If we got this far, something failed, redisplay form
return View(model);
}
public void TestLoginIngresoFallido()
{
var userStore = new Mock<IUserStore<ApplicationUser>>();
var userManager = new Mock<ApplicationUserManager>(userStore.Object);
var authenticationManager = new Mock<IAuthenticationManager>();
var signInManager = new Mock<ApplicationSignInManager>(userManager.Object, authenticationManager.Object);
signInManager.Setup(s => s.PasswordSignInAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<bool>()))
.Returns<string, string, bool, bool>(MockPasswordSignInAsync);
var controller = new AccountController(userManager.Object, signInManager.Object);
var contextMock = new Mock<HttpContextBase>();
controller.Url = new UrlHelper(new RequestContext(contextMock.Object, new RouteData()));
var loginViewmodel = new LoginViewModel
{
Email = "*****@*****.**",
Password = "******",
RememberMe = false
};
var returnUrl = "/Home/Index";
//Act
var result = controller.Login(loginViewmodel, returnUrl);
//Assert
Assert.IsInstanceOfType(result.Result, typeof(ViewResult));
Assert.AreEqual("Usuario o Clave incorrectos", (result.Result as ViewResult).ViewData.ModelState[""].Errors[0].ErrorMessage);
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
// Validate the password
IdentityResult result =
await
this.IdentityManager.Authentication.CheckPasswordAndSignInAsync(
this.AuthenticationManager,
model.UserName,
model.Password,
model.RememberMe);
if (result.Success)
{
return this.RedirectToLocal(returnUrl);
}
else
{
this.AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return this.View(model);
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return View(model);
}
var user = UserManager.FindByEmail(model.Email);
if (user != null && !UserManager.IsEmailConfirmed(user.Id))
{
ModelState.AddModelError("", "Please confirm your account by following the instructions in the confirmation email.");
return View(model);
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
switch (result)
{
case SignInStatus.Success:
return RedirectToLocal(returnUrl);
case SignInStatus.LockedOut:
return View("Lockout");
case SignInStatus.RequiresVerification:
return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return View(model);
}
}
public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
{
ViewBag.ReturnUrl = returnUrl;
if (ModelState.IsValid)
{
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, set shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false);
if (result.Succeeded)
{
return RedirectToLocal(returnUrl);
}
if (result.RequiresTwoFactor)
{
return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
}
if (result.IsLockedOut)
{
return View("Lockout");
}
else
{
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
return View(model);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public Login()
{
loginController = new LoginController();
loginViewModel = loginController.loginViewModel;
this.DataContext = loginController.loginViewModel;
this.InitializeComponent();
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindAsync(model.GaTechId, model.Password);
if (user != null)
{
if (user.EmailConfirmed)
{
await SignInAsync(user, model.RememberMe);
return RedirectToLocal(returnUrl);
}
else
{
ModelState.AddModelError("", "Account activiation is awaiting email confirmation.");
}
}
else
{
ModelState.AddModelError("", "Invalid username or password.");
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
model.RememberMe = true;
if (!ModelState.IsValid)
{
return View(model);
}
SignInStatus result;
try
{
result = await _signInManager.PasswordEmailSignInAsync(model.Email, model.Password
, model.RememberMe, shouldLockout: IdentitySettings.ShouldLockOut);
}
catch(Exception exception)
{
_logger.Exception(exception);
result = SignInStatus.Failure;
}
switch (result)
{
case SignInStatus.Success:
return RedirectToLocal(returnUrl);
case SignInStatus.LockedOut:
return View("Lockout");
case SignInStatus.Failure:
default:
string invalidMessage = IdentityResourceHelper.Load(IdentitySettings.IdentityResource, "AccountController_Login_Invalid");
ModelState.AddModelError("", invalidMessage);
return View(model);
}
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return View(model);
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
switch (result)
{
case SignInStatus.Success:
{
//SessionHelper.UserSessionID = "TEMPSESSIONID";
AspNetUsersController aspUserCon = new AspNetUsersController();
var user = aspUserCon.GetUser(model.Email);
//SessionHelper.UserSessionID = user.Id;
SessionHelper.LoggedInUser<AspNetUser>(user, user.UserName);
return RedirectToLocal(returnUrl);
}
case SignInStatus.LockedOut:
return View("Lockout");
case SignInStatus.RequiresVerification:
return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return View(model);
}
}
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
//if (!ModelState.IsValid) return View(model);
//var user = await UserManager.FindAsync(model.UserName, model.Password);
//if (user != null)
//{
// await SignInAsync(user, model.RememberMe);
// return RedirectToLocal(returnUrl);
//}
//ModelState.AddModelError("", "Invalid username or password.");
//// If we got this far, something failed, redisplay form
//return View(model);
if (!ModelState.IsValid) return View(model);
var user = model.UserName == "Trong"&&model.Password=="123";
if (user){
return RedirectToLocal(returnUrl);
}
ModelState.AddModelError("", "Invalid username or password.");
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task <IActionResult> CreateToken([FromBody] LoginViewModel model)
{
if (ModelState.IsValid)
{
User user = await _userHelper.GetUserAsync(model.Username);
if (user != null)
{
Microsoft.AspNetCore.Identity.SignInResult result = await _userHelper.ValidatePasswordAsync(user, model.Password);
if (result.Succeeded)
{
Claim[] claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, user.Email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
};
SymmetricSecurityKey key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Tokens:Key"]));
SigningCredentials credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
JwtSecurityToken token = new JwtSecurityToken(
_configuration["Tokens:Issuer"],
_configuration["Tokens:Audience"],
claims,
expires: DateTime.UtcNow.AddDays(99),
signingCredentials: credentials);
var results = new
{
token = new JwtSecurityTokenHandler().WriteToken(token),
expiration = token.ValidTo,
user
};
return(Created(string.Empty, results));
}
}
}
return(BadRequest());
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
{
using (ApplicationDbContext db = new ApplicationDbContext())
{
ApplicationUser user = new ApplicationUser();
user = db.Users.First(m => m.Email == model.Email);
user.IsLogin = true;
db.Entry(user).State = EntityState.Modified;
db.SaveChanges();
}
return(RedirectToLocal(returnUrl));
}
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
public void Login_With_Correct_Data()
{
//arrange
Mock <IAuthProvider> mock = new Mock <IAuthProvider>();
mock.Setup(m => m.Authenticate("admin", "123")).Returns(true);
LoginViewModel model = new LoginViewModel
{
UserName = "******",
Password = "******"
};
AccountController controller = new AccountController(mock.Object);
//act
ActionResult result = controller.Login(model, "/MyURL");
//assert
Assert.IsInstanceOfType(result, typeof(RedirectResult));
Assert.AreEqual("/MyURL", ((RedirectResult)result).Url);
}
public async Task <IActionResult> Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false);
if (result.Succeeded)
{
// 防止 Open Redirect
if (!string.IsNullOrEmpty(returnUrl) && Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError(string.Empty, "登录失败，请重试");
}
return(View(model));
}
public async Task <IActionResult> Login(LoginViewModel loginVM)
{
if (!ModelState.IsValid)
{
return(View(loginVM));
}
var usuario = await _userManager.FindByNameAsync(loginVM.UserName);
if (usuario != null)
{
var resultado = await _signInManager.PasswordSignInAsync(usuario, loginVM.Password, false, false);
if (resultado.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
}
ModelState.AddModelError("", "Usuário ou senha inválidos ou não encontrados");
return(View(loginVM));
}
public ActionResult Login(LoginViewModel loginViewModel)
{
ServicePointManager.ServerCertificateValidationCallback = (obj, certificate, chain, errors) => true;
bool canLogIn = false;
using (var authServ = ServiceHelper.GetAuthServiceClient())
{
canLogIn = authServ.Login(loginViewModel.Username, loginViewModel.Password);
}
if (canLogIn)
{
// Sets the current HTTP context to the valid credentials provided
AuthHelper.Login(loginViewModel);
return(RedirectToAction("GetActiveGames", "JoinGame"));
}
else
{
ViewBag.StatusMessage = "Could not log in. Invalid Credentials.";
return(View("Login"));
}
}
public ActionResult Login(LoginViewModel login)
{
if (ModelState.IsValid)
{
var userManager = HttpContext.GetOwinContext().GetUserManager <AppUserManager>();
var authManager = HttpContext.GetOwinContext().Authentication;
AppUser user = userManager.Find(login.UserName, login.Password);
if (user != null)
{
var ident = userManager.CreateIdentity(user,
DefaultAuthenticationTypes.ApplicationCookie);
authManager.SignIn(
new AuthenticationProperties {
IsPersistent = false
}, ident);
return(Redirect(Url.Action("Index", "Home")));
}
}
ModelState.AddModelError("", "Invalid username or password");
return(View(login));
}
public ActionResult Login(LoginViewModel model)
{
//Giriş kontrolü ve yönlendirme yapılacak
//Session'a kullanıcı bilgi saklama
if (ModelState.IsValid) //model doğru gelmişse
{
EvernoteUserManager eum = new EvernoteUserManager();
BusinessLayerResult <EvernoteUser> res = eum.LoginUser(model);
//demekki hata var
if (res.Errors.Count > 0)
{
res.Errors.ForEach(x => ModelState.AddModelError("", x.Message));//ilgili hatayı metoda ekle dedik.foreach ile .bu hatayıda view tarafında Validation summary ile okuyor.
//business layerdan dönen hataların yönetimi
if (res.Errors.Find(x => x.Code == ErrorMessageCode.UserIsNotActive) != null)
{
ViewBag.SetLink = "http://Home/Activate/1313-4344345-345345";
}
return(View(model));
}
//giriş başarılı ise
Session["login"] = res.Result; //sessiona kullanıcı bilgisini at
return(RedirectToAction("Index")); //yönlendirme ..
}
return(View(model));
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// Uncomment to require the user to have a confirmed email before they can log on.
var user = await _userManager.FindByNameAsync(model.Email);
if (user != null)
{
if (!await _userManager.IsEmailConfirmedAsync(user.Id))
{
string callbackUrl = await SendEmailConfirmationTokenAsync(user.Id, "Confirm your account-Resend");
ViewBag.ErrorMessage = "You must have a confirmed email to log on.";
return(View("Error"));
}
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
public async Task <IActionResult> Login(LoginViewModel model)
{
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false);
if (result.Succeeded)
{
if (!string.IsNullOrEmpty(model.ReturnUrl) && Url.IsLocalUrl(model.ReturnUrl))
{
return(Redirect(model.ReturnUrl));
}
else
{
//проверяем роли и направляем по личным кабинетам
User user = await _userManager.FindByEmailAsync(model.Email);
var userRoles = await _userManager.GetRolesAsync(user);
foreach (var role in userRoles)
{
if (role == "admin")
{
return(RedirectToAction("Index", "Roles"));//личный абинет администратора-методиста
}
else
{
return(RedirectToAction("Index", "Student"));//линый кабинет студента
}
}
}
}
else
{
ModelState.AddModelError("", "Неправильный логин и (или) пароль");
}
}
return(View(model));
}
public async Task <IActionResult> Login([FromBody] LoginViewModel model)
{
if (ModelState.IsValid)
{
await HttpContext.Authentication.SignOutAsync(_externalCookieScheme);
ClaimsPrincipal principal = HttpContext.User as ClaimsPrincipal;
await HttpContext.Authentication.SignInAsync("MyCookieAuthenticationScheme", principal);
var userTask = _userManager.FindByEmailAsync(model.Email);
var user = userTask.Result;
if (user != null)
{
var result = await _signInManager.PasswordSignInAsync(user.Email, model.Password, model.RememberMe, lockoutOnFailure : false);
if (result.Succeeded)
{
//var user = _context.Users.SingleOrDefault(u => u.Email.Equals(model.Email));
_logger.LogInformation(1, "User logged in.");
return(Ok(user));
}
if (result.IsLockedOut)
{
_logger.LogWarning(2, "User account locked out.");
return(View("Lockout"));
}
else
{
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
return(StatusCode(400, "Nem sikerült a bejelentkezés."));
}
}
}
// If we got this far, something failed, redisplay form
return(BadRequest());
}
public async Task <IActionResult> Register(LoginViewModel registro)
{
if (ModelState.IsValid)
{
var usuario = new IdentityUser()
{
UserName = registro.UserName
};
var result = await _userManager.CreateAsync(usuario, registro.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(usuario, "Member");
await _signInManager.SignInAsync(usuario, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
}
return(View(registro));
}
public ActionResult Login(LoginViewModel model)
{
ActionResult result = null;
try
{
if (!ModelState.IsValid)
{
throw new Exception();
}
_vm.LoginUser(model.Username, model.Password);
result = RedirectToAction("Index", "Vending");
}
catch (Exception)
{
result = View("Login");
}
return result;
}
public async Task <IActionResult> Login(LoginViewModel model)
{
if (ModelState.IsValid)
{
var user = await _loginService.FindByUsername(model.Email);
if (await _loginService.ValidateCredentials(user, model.Password))
{
var tokenLifetime = _configuration.GetValue("TokenLifetimeMinutes", 120);
var props = new AuthenticationProperties
{
ExpiresUtc = DateTimeOffset.UtcNow.AddMinutes(tokenLifetime),
AllowRefresh = true,
RedirectUri = model.ReturnUrl
};
if (model.RememberMe)
{
var permanentTokenLifetime = _configuration.GetValue("PermanentTokenLifetimeDays", 365);
props.ExpiresUtc = DateTimeOffset.UtcNow.AddDays(permanentTokenLifetime);
props.IsPersistent = true;
}
;
await _loginService.SignInAsync(user, props);
if (_interaction.IsValidReturnUrl(model.ReturnUrl))
{
return(Redirect(model.ReturnUrl));
}
}
model.Message = "Wrong username and password";
}
var vm = await BuildLoginViewModelAsync(model);
var result = await _userService.GetFloristThemeIds(50);
vm.ThemeId = result.KeyId;
return(View(vm));
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
return(RedirectToAction("Index", "Customer"));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
public IActionResult Login(LoginViewModel model)
{
bool passwordCheck = false;
bool userCheck = false;
List <string> errors = new List <string>();
if (ModelState.IsValid)
{
User currentUser = _context.User.SingleOrDefault(user => user.Email == model.Email);
if (currentUser != null && currentUser.Email.Equals(model.Email))
{
PasswordHasher <User> Hasher = new PasswordHasher <User>();
if (0 != Hasher.VerifyHashedPassword(currentUser, currentUser.Password, model.Password))
{
HttpContext.Session.SetInt32("CurrUserId", (int)currentUser.id);
return(RedirectToAction("Index", "New"));
}
passwordCheck = true;
}
else
{
userCheck = true;
}
}
errors = ModelState.Select(x => x.Value.Errors)
.Where(y => y.Count > 0)
.Select(z => z[0].ErrorMessage.ToString())
.ToList();
if (passwordCheck == true)
{
errors.Add("Password was incorrect.");
}
if (userCheck == true)
{
errors.Add("User doesn't exist is the Database.");
}
TempData["error_list"] = errors;
return(RedirectToAction("Index"));
}
public void Login_With_Incorrect_Data()
{
//arrange
Mock <IAuthProvider> mock = new Mock <IAuthProvider>();
mock.Setup(m => m.Authenticate("user", "228")).Returns(false);
LoginViewModel model = new LoginViewModel
{
UserName = "******",
Password = "******"
};
AccountController controller = new AccountController(mock.Object);
//act
ActionResult result = controller.Login(model, "/MyURL");
//assert
Assert.IsInstanceOfType(result, typeof(ViewResult));
Assert.IsFalse(((ViewResult)result).ViewData.ModelState.IsValid);
}
public async Task <IActionResult> Login(LoginViewModel loginViewModel)
{
if (!ModelState.IsValid)
{
return(View(loginViewModel));
}
var user = await _userManager.FindByNameAsync(loginViewModel.UserName);
if (user != null)
{
var result = await _signInManager.PasswordSignInAsync(user, loginViewModel.Password, false, false);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
}
ModelState.AddModelError("", "用户名/密码错误");
return(View(loginViewModel));
}
public async Task <ActionResult> Login(LoginViewModel details, string returnUrl)
{
AppUser user = await UserManager.FindAsync(details.Name, details.Password);
if (user == null)
{
ModelState.AddModelError("", "Некорректное имя или пароль.");
}
else
{
ClaimsIdentity ident = await UserManager.CreateIdentityAsync(user,
DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignOut();
AuthManager.SignIn(new AuthenticationProperties
{
IsPersistent = false
}, ident);
return(Redirect(returnUrl));
}
return(View(details));
}
public async Task<ActionResult> Login(LoginViewModel lvm, string returnUrl)
{
//if user forgot to include user name or password,
//send them back to the login page to try again
if (ModelState.IsValid == false)
{
return View(lvm);
}
// finds the roleID
string? roleID = _context.Roles.Where(r => r.Name == "FiredEmployee").FirstOrDefault().Id;
// finds the user
AppUser user = _context.Users.Where(u => u.Email == lvm.Email).FirstOrDefault();
// finds the roleID tied to the user
string userroleid = _context.UserRoles.Where(ur => ur.UserId == user.Id).FirstOrDefault().RoleId;
if (userroleid == roleID)
{
return View("Error", new String[] { "You are fired!" });
}
//attempt to sign the user in using the SignInManager
Microsoft.AspNetCore.Identity.SignInResult result = await _signInManager.PasswordSignInAsync(lvm.Email, lvm.Password, lvm.RememberMe, lockoutOnFailure: false);
//if the login worked, take the user to either the url
//they requested OR the homepage if there isn't a specific url
if (result.Succeeded)
{
//return ?? "/" means if returnUrl is null, substitute "/" (home)
return RedirectToAction("CheckFired");
}
else //log in was not successful
{
//add an error to the model to show invalid attempt
ModelState.AddModelError("", "Invalid login attempt.");
//send user back to login page to try again
return View(lvm);
}
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = HttpContext.GetOwinContext().Get <SignInManager>()
.PasswordSignIn(model.UserName, model.Password, false, false);
if (result == SignInStatus.Success)
{
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "The user name or password provided is incorrect.");
return(View(model));
}
public ActionResult Login(LoginViewModel lvm)
{
var user = new User();
using (Model1Container context = new Model1Container())
{
user = context.Users.Where(a => a.username == lvm.username && a.password == lvm.password).FirstOrDefault();
}
if (user == null)
{
ModelState.AddModelError("", "Invalid username or password!");
}
else
{
//ModelState.AddModelError("", "Successful");
Session["LogonUser"] = user;
return(RedirectToAction("Index", "Home"));
//("Index = Page", "Home = Controller")
}
return(View());
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindAsync(model.Email, model.Password);
if (user != null)
{
await SignInAsync(user, model.RememberMe);
return(RedirectToLocal(returnUrl));
}
else
{
ModelState.AddModelError("", "Invalid username or password.");
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> SignIn([FromBody] LoginViewModel model)
{
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, false, false);
if (result.Succeeded)
{
var user = await _userManager.FindByNameAsync(model.UserName);
return(new JsonResult(new Dictionary <string, object>
{
{ "access_token", GetToken(user) }
}));
}
return(new JsonResult("Unable to sign in")
{
StatusCode = 401
});
}
return(Error("Unexpected error"));
}
public IActionResult Post(LoginViewModel login)
{
Usuario usuarioBuscado = _usuario.BuscarPorEmailSenha(login.Email, login.Senha);
if (usuarioBuscado == null)
{
return NotFound("E-mail ou senha inválidos");
}
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Email, usuarioBuscado.Email),
new Claim(JwtRegisteredClaimNames.Jti, usuarioBuscado.IdUsuario.ToString()),
new Claim(ClaimTypes.Role, usuarioBuscado.IdTipousuario.ToString())
};
var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes("Senatur-chave-autenticacao"));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: "Senatur.WebApi", // emissor do token
audience: "Senatur.WebApi", // destinatário do token
claims: claims, // dados definidos acima
expires: DateTime.Now.AddMinutes(30), // tempo de expiração
signingCredentials: creds // credenciais do token
);
return Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
});
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View());
}
if (!ValidateUser(model.Login, model.Password))
{
ModelState.AddModelError(string.Empty, "Le nom d'utilisateur ou le mot de passe est incorrect.");
return(View(model));
}
SetIdentityToCookie(model);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> CreateToken([FromBody] LoginViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(model.Username);
if (user != null)
{
var result = await _signInManager.CheckPasswordSignInAsync(user, model.Password, false);
if (result.Succeeded)
{
var claims = new[]
{
//Create the token
new Claim(JwtRegisteredClaimNames.Sub, user.Email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.UniqueName, user.UserName)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Tokens:Key"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
_config["Tokens:Issuer"],
_config["Tokens:Audience"],
claims,
expires: DateTime.UtcNow.AddMinutes(30),
signingCredentials: creds
);
var results = new
{
token = new JwtSecurityTokenHandler().WriteToken(token),
expiration = token.ValidTo
};
return(Created("", results));
}
}
}
return(BadRequest());
}
public async Task <IActionResult> Login(LoginViewModel model)
{
if (ModelState.IsValid)
{
var result = await _userHelper.LoginAsync(model);
if (result.Succeeded)
{
if (Request.Query.Keys.Contains("ReturnUrl"))
{
return(Redirect(Request.Query["ReturnUrl"].First()));
}
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError(string.Empty, "User or password incorrect.");
}
return(View(model));
}
public ActionResult LogIn(LoginViewModel request)
{
if (ModelState.IsValid)
{
BusinessLayerResult <EvernoteUser> res = evernoteUserManager.LoginUser(request);
if (res.Errors.Count > 0)
{
res.Errors.ForEach(x => ModelState.AddModelError("", x.message));
if (res.Errors.Find(x => x.code == ErrorMessageCode.UserIsNotActive) != null)
{
ViewBag.SetLik = "http://Home/Activa/1234-5678-8987";
}
return(View(request));
}
CurrentSession.Set <EvernoteUser>("login", res.Result); //session'a kullanıcı bilgi saklama
return(RedirectToAction("Index"));
}
return(View());
}
public async Task<IActionResult> Login(LoginViewModel model, string returnUrl)
{
model.ExternalLogins = model.ExternalLogins ?? (await signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = await userManager.FindByEmailAsync(model.Email);
if(user != null && !user.EmailConfirmed &&
(await userManager.CheckPasswordAsync(user,model.Password)))
{
ModelState.AddModelError(string.Empty, "Email not confirmed yet");
return View(model);
}
var result = await signInManager.PasswordSignInAsync(model.Email, model.Password,
model.RememberMe, true);
if (result.Succeeded)
{
if (!string.IsNullOrEmpty(returnUrl) && Url.IsLocalUrl(returnUrl))
{
return Redirect(returnUrl);
}
else
{
return RedirectToAction("Index", "home");
}
}
if(result.IsLockedOut)
{
return View("AccountLocked");
}
ModelState.AddModelError(string.Empty, "Invalid Login Attempt");
}
return View(model);
}
