public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (!Request.IsAuthenticated)
{
if (_authProvider.Authenticate(model.Username, model.Password, false))
{
return(Redirect(returnUrl ?? Url.Action("Index", "Home")));
}
}
return(View());
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (authProvider.Authenticate(model.UserName, model.Password))
{
return(RedirectToAction("Index", "Home"));
}
else
{
ViewBag.Error = "Неправильный логин или пароль";
return(View());
}
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (provider.Authenticate(model.Name, model.Password))
{
return(Redirect(returnUrl ?? Url.Action("Index", "Home")));
}
ModelState.AddModelError("", "Неправильный логин или пароль");
return(View());
}
return(View());
}
public void Authenticate_Test()
{
// arrange in ctor
var email = "*****@*****.**";
var password = "******";
// act
var authenticatedUser = _auth.Authenticate(email, password);
// assert
Assert.IsNotNull(authenticatedUser);
Assert.IsInstanceOfType(authenticatedUser, typeof(User));
Assert.AreEqual(email, authenticatedUser.Email);
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (authProvider.Authenticate(model.UserName, model.Password))
{
Logger log = new Logger();
using (StreamWriter w = System.IO.File.AppendText("C:\\temp\\log.txt"))
{
log.LogToFile(model.UserName + " has logged in", w);
}
return(RedirectToAction("Login", "Account"));
return(Redirect(returnUrl ?? Url.Action("Index", "Admin")));
}
else
{
ModelState.AddModelError("", "Your credentials are incorrect");
return(View());
}
}
else
{
return(View());
}
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
//map loginview to LogData
var data = Mapper.Map <LoginViewModel, LogData>(model);
if (_authProvider.Authenticate(model.Email, model.Password))
{
data.Success = true;
_urepo.CreateLog(data);
return(Redirect(returnUrl ?? Url.Action("Index", "Default")));
}
else
{
data.Success = false;
_urepo.CreateLog(data);
ModelState.AddModelError("", "Incorrect username or password");
return(View());
}
}
else
{
return(View());
}
}
public ActionResult Login(LoginViewModel model, string returnUrl = "")
{
if (ModelState.IsValid)
{
if (authprovider.Authenticate(model.Username, model.Password))
{
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel();
serializeModel.Username = model.Username;
string userData = JsonConvert.SerializeObject(serializeModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
1,
model.Username,
DateTime.Now,
DateTime.Now.AddMinutes(15),
false,
userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
if (Response != null)
{
Response.Cookies.Add(faCookie);
}
return(Redirect(returnUrl ?? Url.Action("Index", "Home")));
}
ModelState.AddModelError("", "Incorrect username and/or password");
}
return(View(model));
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var user = userRepository.GetAllUsers().FirstOrDefault(x => x.Email.Equals(model.Email) &&
x.Password.Equals(model.Password));
if (user != null)
{
if (!user.ActivationStatus)
{
ModelState.AddModelError("NotActivatedAccount", "Please activate your account!");
return(View());
}
authProvider.Authenticate(model.Email, model.Password);
Session["CurrentUserId"] = user.UserId;
return(Redirect(returnUrl ?? Url.Action("Index", "Fish")));
}
else
{
ModelState.AddModelError("IncorrectInfo", "Incorrect e-mail or password!");
return(View());
}
}
else
{
return(View());
}
}
public ActionResult Index(LoginViewModel loginVm)
{
User user = _userRepository.GetUserByNickname(loginVm.Login);
if (user == null)
{
TempData["errorMessage"] = "Account was not found";
return(View(new LoginViewModel()));
}
if (!user.AccountConfirmed)
{
TempData["errorMessage"] = "Account was not confirmed";
return(View(new LoginViewModel()));
}
bool result = _authProvider.Authenticate(loginVm.Login, loginVm.Password);
if (!result)
{
//ModelState.AddModelError("Error", "Login or password was incorrect");
TempData["errorMessage"] = "Login or password was incorrect";
return(View(new LoginViewModel()));
}
return(RedirectToAction("Page", "Account", new { login = loginVm.Login }));
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var kullanici = kullaniciRepo.Kullanicilar.FirstOrDefault(x => x.KullaniciAdi.Equals(model.KullaniciAdi) && x.Sifre.Equals(model.Sifre) && x.IsAdmin.Equals(true));
if (kullanici != null)
{
authProvider.Authenticate(model.KullaniciAdi, model.Sifre);
Session["CurrentUserName"] = kullanici.KullaniciAdi;
Session["CurrentUserName_SurName"] = kullanici.Adi + " " + kullanici.Soyadi;
Session["CurrentUserId"] = kullanici.KullaniciId;
Session["CurrentUser_Auths"] = new KullaniciYetkileri(grupRepo.KullaniciYetkileri(kullanici.KullaniciId));
return(Redirect(returnUrl ?? Url.Action("Index", "Default")));
}
else
{
ModelState.AddModelError("", "Kullanıcı adı veya parola hatalı!");
return(View());
}
}
else
{
return(View());
}
}
public ActionResult Login(LoginViewModel model, string returnUrl, CurrentUser user)
{
if (ModelState.IsValid)
{
if (authProvider.Authenticate(model.Username, model.Password))
{
user.Data = repository.Items.FirstOrDefault(x => x.Email == "*****@*****.**");
user.isAdmin = true;
if (returnUrl != null)
{
return(Redirect(returnUrl));
}
return(RedirectToAction("List", "Product"));
}
user.Data = repository.Items.FirstOrDefault(x => x.Email == model.Username);
if (user.Data != null)
{
if (user.Data.Password == model.Password)
{
return(Redirect(returnUrl));
}
else
{
user = null;
}
}
}
ModelState.AddModelError("", "Неправильний логин или пароль");
return(View(model));
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (authProvider.Authenticate(model.Login, model.Password))
{
//return Redirect(returnUrl ?? Url.Action("Index", "ProjectManagement"));
if (returnUrl != null)
{
return(Redirect(returnUrl));
}
if (model.PreviousUrl == null)
{
return(RedirectToAction("Index", "TimeReports"));
}
return(Redirect(model.PreviousUrl));
}
else
{
ModelState.AddModelError("", "Неправильный логин или пароль");
return(View());
}
}
else
{
return(View());
}
}
public ActionResult Login(LoginViewModel model)
{
string message = Translation.Translation.LoginPageLoginError;
if (ModelState.IsValid)
{
string phone = StringHelper.GetOnlyNumbers(model.Phone);
model.Phone = phone;
if (phone.Length == 12)
{
AuthResult authResult = _authProvider.Authenticate(phone, model.Password);
if (authResult == AuthResult.Success)
{
return(Redirect(Url.Action("Users", "Default")));
}
else if (authResult == AuthResult.NoRights)
{
message = Translation.Translation.AccessIsDeniedMessage;
}
}
}
ModelState.AddModelError("", message);
return(View(model));
}
private bool ValidateUserNamePasswordLogin(LoginModel login, string redirectUrl, out ActionResult redirect)
{
try
{
if (authProvider.Authenticate(login.Name, login.UserName, login.Password))
{
redirect = Redirect(redirectUrl);
return(true);
}
}
catch (InvalidCredentialsException)
{
ModelState.AddModelError("", "Invalid user name or password");
RedirectToAction("Fail");
}
catch (UserNotAuthenticatedException)
{
ModelState.AddModelError("", "User could not be identified");
RedirectToAction("Fail");
}
catch (UnsupportedAuthenticationType)
{
ModelState.AddModelError("", "Authentication mode not supported");
RedirectToAction("Fail");
}
catch (Exception)
{
ModelState.AddModelError("", "Something went wrong");
redirect = View();
return(true);
}
redirect = View();
return(false);
}
public ActionResult Login(LoginViewModel login, string returnUrl)
{
if (ModelState.IsValid)
{
if (authProvider.Authenticate(login.Email, login.Password))
{
FormsAuthentication.SetAuthCookie(login.Email, false);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
String role = Roles.GetRolesForUser(login.Email).SingleOrDefault();
if (role.Equals("administrateur"))
{
return(RedirectToAction("Index", "Home", new { area = "Admin" }));
}
else
{
return(RedirectToAction("Index", "MesAnnonces"));
}
}
}
else
{
ModelState.AddModelError("", "Votre Email ou votre mot de passe est incorrect");
}
}
return(View(login));
}
/// <summary>
/// The specified <paramref name="session"/> may change as a side-effect of this method. If
/// subsequent code relies on current <see cref="IAuthSession"/> data be sure to reload
/// the session istance via <see cref="ServiceExtensions.GetSession(IServiceBase,bool)"/>.
/// </summary>
private object Authenticate(Authenticate request, string provider, IAuthSession session, IAuthProvider oAuthConfig)
{
if (request.provider == null && request.UserName == null)
{
return(null); //Just return sessionInfo if no provider or username is given
}
var authFeature = HostContext.GetPlugin <AuthFeature>();
var generateNewCookies = authFeature == null || authFeature.GenerateNewSessionCookiesOnAuthentication;
object response = null;
if (!oAuthConfig.IsAuthorized(session, session.GetAuthTokens(provider), request))
{
if (generateNewCookies)
{
this.Request.GenerateNewSessionCookies(session);
}
response = oAuthConfig.Authenticate(this, session, request);
}
else
{
if (generateNewCookies)
{
this.Request.GenerateNewSessionCookies(session);
oAuthConfig.SaveSession(this, session, (oAuthConfig as AuthProvider)?.SessionExpiry);
}
}
return(response);
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (authProvider.Authenticate(model.UserName, model.Password))
{
//Write to a file when user loggin
Logger l = new Logger();
using (StreamWriter w = System.IO.File.AppendText("C:\\Temp\\useraccess.log"))
{
l.LogToFile(", " + model.UserName + ", logged in,", w);
}
return(Redirect(returnUrl ?? Url.Action("Index", "Admin")));
}
else
{
ModelState.AddModelError("", "Incorrect username or password");
return(View());
}
}
else
{
return(View());
}
}
public async Task <ActionResult> Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (authProvider.Authenticate(model.Email, model.Password))
{
return(Redirect(Url.Action("Index", "Admin")));
}
ApplicationUser user = await UserManager.FindAsync(model.Email, model.Password);
if (user == null)
{
ModelState.AddModelError("", "Неверный логин или пароль.");
}
else
{
ClaimsIdentity claim = await UserManager.CreateIdentityAsync(user,
DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(new AuthenticationProperties
{
IsPersistent = true
}, claim);
if (String.IsNullOrEmpty(returnUrl))
{
return(RedirectToAction("Index", "Home"));
}
return(Redirect(returnUrl));
}
}
ViewBag.returnUrl = returnUrl;
return(View(model));
}
public IActionResult Authenticate([FromBody] AuthRequest request)
{
try
{
if (string.IsNullOrEmpty(request.Username) || string.IsNullOrEmpty(request.Password))
{
return(BadRequest("You must send in a user name and password"));
}
var response = _authService.Authenticate(request.Username, request.Password);
if (response.Authenticated)
{
return(Ok(response));
}
else
{
return(Unauthorized("Invalid user or password"));
}
}
catch (Exception ex)
{
return(Problem("Something is broke, yo")); //TODO: Probably shouldn't do this
}
}
public void Authenticate_CorrectUser_ReturnsUser()
{
_sut = new AuthProvider(_userServiceMock.Object);
var result = _sut.Authenticate(new Login());
Assert.AreEqual("test", result.Login);
Assert.AreEqual("test", result.Password);
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (authProvider.Authenticate(model.UserName, model.Password))
{
return(Redirect(returnUrl ?? Url.Action("Manager", "Cabinet")));
}
else
{
ModelState.AddModelError("notLog", "Неверный логин или пароль");
return(View());
}
}
else
{
return(View());
}
}
/// <summary>
/// The specified <paramref name="session"/> may change as a side-effect of this method. If
/// subsequent code relies on current <see cref="IAuthSession"/> data be sure to reload
/// the session istance via <see cref="ServiceExtensions.GetSession(SStack.ServiceInterface.IServiceBase,bool)"/>.
/// </summary>
private object Authenticate(Auth request, string provider, IAuthSession session, IAuthProvider oAuthConfig)
{
object response = null;
if (!oAuthConfig.IsAuthorized(session, session.GetOAuthTokens(provider), request))
{
response = oAuthConfig.Authenticate(this, session, request);
}
return(response);
}
public ActionResult Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (authProvider.Authenticate(model.UserName, model.Password, model.RememberMe))
{
return(RedirectToLocal(returnUrl));
}
else
{
// If we got this far, something failed, redisplay form
ModelState.AddModelError("", "The user name or password provided is incorrect.");
return(View(model));
}
}
else
{
return(View(model));
}
}
public ActionResult Login(string username, string pwd)
{
authProvider.Authenticate(username, () =>
{
return(username == "admin" && pwd == "Win2003@");
});
Session[AppConfig.UserSessionKey] = new UserSession(username, "admin");
return(RedirectToAction("LoginInfo"));
}
public ActionResult Login(LoginUser user, string returnUrl = null)
{
if (!string.IsNullOrWhiteSpace(user.UserName) &&
!string.IsNullOrWhiteSpace(user.Password) &&
ModelState.IsValid)
{
if (authProvider.Authenticate(user.UserName, user.Password))
{
return(Redirect(returnUrl ?? Url.Action("Index", "Admin")));
}
else
{
ModelState.AddModelError("Enter", "Неправильный логин или пароль");
return(View());
}
}
else
{
return(View());
}
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (authProvider.Authenticate(model.UserName, model.Password))
{
return(Redirect(returnUrl ?? Url.Action("Index", "Admin")));
}
else
{
ModelState.AddModelError("", "Неправильный логин или пароль");
return(View());
}
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (authProvider.Authenticate(model.UserName, model.Password))
{
return(Redirect(returnUrl ?? Url.Action("Index", "Admin")));
}
ModelState.AddModelError("", "Nieprawidłowa nazwa użytkownika lub niepoprawne hasło.");
return(View());
}
return(View());
}
public ActionResult Login(LoginViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (authProvider.Authenticate(model.UserName, model.Password))
{
return(Redirect(returnUrl ?? Url.Action("Index", "Admin")));
}
ModelState.AddModelError("", "Incorrect username or password");
return(View());
}
return(View());
}
public ActionResult Login(AuthenticationModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (_authProvider.Authenticate(model.Name, model.Password))
{
return(Redirect(returnUrl ?? Url.Action("MyPanel", "Admin")));
}
ModelState.AddModelError("", "Неправильный логин или пароль");
return(View());
}
return(View());
}
public ActionResult LoginUpdated(LoginViewModelUpdated model, string returnUrl)
{
if (ModelState.IsValid)
{
if (_iAuthProvider.Authenticate(model.UserName, model.Password))
{
return(Redirect(returnUrl ?? Url.Action("Index", "Product")));
}
ModelState.AddModelError("", "Incorrect Username or Password");
return(View("Login"));
}
return(View("Login"));
}
/// <summary>
/// The specified <paramref name="session"/> may change as a side-effect of this method. If
/// subsequent code relies on current <see cref="IAuthSession"/> data be sure to reload
/// the session istance via <see cref="ServiceExtensions.GetSession(IServiceBase,bool)"/>.
/// </summary>
private object Authenticate(Authenticate request, string provider, IAuthSession session, IAuthProvider oAuthConfig)
{
if (request.provider == null && request.UserName == null)
return null; //Just return sessionInfo if no provider or username is given
var authFeature = HostContext.GetPlugin<AuthFeature>();
var generateNewCookies = authFeature == null || authFeature.GenerateNewSessionCookiesOnAuthentication;
object response = null;
if (!oAuthConfig.IsAuthorized(session, session.GetOAuthTokens(provider), request))
{
if (generateNewCookies)
this.Request.GenerateNewSessionCookies(session);
response = oAuthConfig.Authenticate(this, session, request);
}
else
{
if (generateNewCookies)
{
this.Request.GenerateNewSessionCookies(session);
this.Request.SaveSession(session);
}
}
return response;
}
/// <summary>
/// The specified <paramref name="session"/> may change as a side-effect of this method. If
/// subsequent code relies on current <see cref="IAuthSession"/> data be sure to reload
/// the session istance via <see cref="ServiceExtensions.GetSession(IServiceBase,bool)"/>.
/// </summary>
private object Authenticate(Authenticate request, string provider, IAuthSession session, IAuthProvider oAuthConfig)
{
object response = null;
if (!oAuthConfig.IsAuthorized(session, session.GetOAuthTokens(provider), request))
{
response = oAuthConfig.Authenticate(this, session, request);
}
return response;
}
/// <summary>
/// The specified <paramref name="session"/> may change as a side-effect of this method. If
/// subsequent code relies on current <see cref="IAuthSession"/> data be sure to reload
/// the session istance via <see cref="ServiceExtensions.GetSession(IServiceBase,bool)"/>.
/// </summary>
private object Authenticate(Authenticate request, string provider, IAuthSession session, IAuthProvider oAuthConfig)
{
if (request.provider == null && request.UserName == null)
return null; //Just return sessionInfo if no provider or username is given
object response = null;
if (!oAuthConfig.IsAuthorized(session, session.GetOAuthTokens(provider), request))
{
response = oAuthConfig.Authenticate(this, session, request);
}
return response;
}
