public ActionResult SignIn(SignInModel model, string returnUrl) { if (ModelState.IsValid) { if (MembershipService.ValidateUser(model.UserName, model.Password)) { FormsService.SignIn(model.UserName, model.RememberMe); if (!String.IsNullOrEmpty(returnUrl)) { return(Redirect(returnUrl)); } else { return(RedirectToAction("Index", "Home")); } } else { ModelState.AddModelError("", "The user name or password provided is incorrect."); } } // If we got this far, something failed, redisplay form return(View(model)); }
public ActionResult SignIn(SignInModel model) { try { SignInResult result = AccountsManager.Authenticate(model.Username, model.Password); if (result.Ok) { // Set the authentication cookie FormsAuthentication.SetAuthCookie(result.Username, true); } else { return(CreateValidationError(result.Reason)); } return(JsonOK()); } catch (Exception ex) { EventLog.WriteEntry("Krypto", "An error occured while trying to sign-in: " + ex.Message); return(CreateValidationError("Internal Server Error")); } }
public IActionResult SignIn(SignInModel obj) { if (ModelState.IsValid) { Member member = app.Member.SignIn(obj.Usr, obj.Pwd); if (member != null) { ClaimsIdentity claims = new ClaimsIdentity(CookieAuthenticationDefaults.AuthenticationScheme); claims.AddClaim(new Claim(ClaimTypes.NameIdentifier, member.Id.ToString())); claims.AddClaim(new Claim(ClaimTypes.Name, member.Username)); claims.AddClaim(new Claim(ClaimTypes.Email, member.Email)); //load roles if (member.Roles != null) { foreach (Role item in member.Roles) { claims.AddClaim(new Claim(ClaimTypes.Role, item.Name)); } } AuthenticationProperties properties = new AuthenticationProperties { AllowRefresh = true, IsPersistent = obj.Remember, }; HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(claims), properties); return(Redirect("/")); } else { ModelState.AddModelError("error", "Đăng nhập bị lỗi!"); } } return(View(obj)); }
public ActionResult <SignInModel> SignIn( [FromForm] string sEmail , [FromForm] string sPW) { ApiResultReady armResult = new ApiResultReady(this); //로그인 처리용 모델 SignInModel smResult = new SignInModel(); armResult.ResultObject = smResult; if (sEmail == "*****@*****.**" && sPW == "1111") { smResult.Complete = true; //이 프로젝트에서는 사인인한 유저의 정보를 어디에도 저장하지 않는다. //그래서 토큰으로 유저를 구분할 수 있게 만든다. smResult.Token = string.Format("{0}▩{1}" , sEmail , Guid.NewGuid().ToString()); } else { armResult.InfoCode = "-1"; armResult.Message = "일치하는 정보가 없습니다."; smResult.Complete = false; } return(armResult.ToResult()); }
public static bool authenticate(IWorkUnit workUnit, SignInModel logOnModel) { var password = logOnModel.Password; Account account = null; try { //get the contact with the provided email account = workUnit.AccountRepository.Entities.First(x => x.EmailAddress.ToUpper() == logOnModel.Email.ToUpper()); } catch { return(false);//failed to find user account } //encode password var encodedPassword = SHA1PasswordSecurity.encrypt(password); //authenticate var databasePassword = account.Password; var pwValidation = comparePassword(encodedPassword, databasePassword); //if valid record log in datetime if (pwValidation) { try { account.LastLogin = DateTime.Now; workUnit.AccountRepository.UpdateEntity(account); workUnit.saveChanges(); } catch { //do error logging here } } return(pwValidation); }
public Task <IResult <string> > SignInAsync(SignInModel signInModel) { var validation = new SignInModelValidator().Valid(signInModel); if (!validation.Success) { return(Task.FromResult(validation)); } var signedInModel = UserRepository.SignInAsync(signInModel).Result; validation = new SignedInModelValidator().Valid(signedInModel); if (!validation.Success) { return(Task.FromResult(validation)); } var userLogModel = new UserLogModel(signedInModel.UserId, LogType.Login); UserLogDomain.AddAsync(userLogModel); var jwt = CreateJwt(signedInModel); return(new SuccessResult <string>(jwt).ToTask()); }
//[ValidateAntiForgeryToken] public async Task <IActionResult> SignIn(SignInModel model) { if (User.Identity.IsAuthenticated) { return(RedirectToDefault); } if (!ModelState.IsValid) { return(RedirectToDefault.WithError(JoinWithHtmlLineBreak(ModelState.GetErrorMessages()))); } try { var signInResult = await _authService.SignInAsync(model.NameOrEmail, model.Password, false); if (signInResult.IsLockedOut) { return(View("Lockout")); } return(signInResult.Succeeded ? RedirectToDefault : RedirectToDefault.WithError(MessagesOptions.LoginFailed)); } catch (Exception exception) { _appLogger.LogError(exception); return(RedirectToDefault.WithError(exception.Message)); } }
public async Task <IActionResult> SignIn([FromBody] SignInModel signIn, string returnUrl = null) { try { if (string.IsNullOrEmpty(returnUrl)) { return(BadRequest("returnUrl is null or empty")); } if (ModelState.IsValid) { var result = await _signInManager.PasswordSignInAsync(signIn.Email, signIn.Password, signIn.IsRememberMe, true); if (result.Succeeded) { return(Redirect(returnUrl)); } return(BadRequest("Authentication failed")); } return(BadRequest()); } catch (Exception ex) { _logger.LogDebug(ex.Message); return(InternalServerError($"Errors:{ex.Message}")); } }
public void SignIn(SignInModel user) { SignInModule module = new SignInModule(); m_user = module.GetUserBySignID(user); if (m_user == null) { throw new Exception("請輸入正確帳號或密碼"); } if (m_user.UserAccount == "manager") { m_user.Role = UserRoleEnum.SUPERADMIN; } else if (m_user.UserAccount == "admin") { m_user.Role = UserRoleEnum.ADMIN; } else { m_user.Role = UserRoleEnum.USER; } Context.Session["UserInfo"] = m_user; //寫入登入紀錄 //string ip = System.Web.HttpContext.Current.Request.UserHostAddress; //IpHistoryModule ipMdu = new IpHistoryModule(); //ipMdu.WriteIp(ip, "manager"); //ipMdu.Dispose(); }
public async Task <IActionResult> SignIn(SignInModel model) { if (model == null || string.IsNullOrEmpty(model.Username) || string.IsNullOrEmpty(model.Password)) { return(BadRequest("Required parameters missing.")); } var user = await _dbService.Users.FindByUsernameAsync(model.Username); if (user == null || !_authService.VerifyPassword(user.Password, model.Password)) { if (user != null) { var failureCount = (user.BadPasswordCount ?? 0) + 1; var windowStart = user.BadPasswordWindowStart ?? DateTime.UtcNow; var windowEnd = windowStart.Add(TimeSpan.FromHours(1)); if (DateTime.UtcNow > windowEnd) { user.BadPasswordWindowStart = DateTime.UtcNow; user.BadPasswordCount = 1; } else if (failureCount >= 3) { user.IsLockedOut = true; } else { user.BadPasswordWindowStart = windowStart; user.BadPasswordCount = failureCount; } user.ModifiedDate = DateTime.UtcNow; await _dbService.Users.UpdateAsync(user); } return(BadRequest("Invalid username or password.")); } var claims = new List <Claim> { new Claim(ClaimTypes.Name, user.Username), new Claim(ClaimTypes.Email, user.Email), new Claim(ClaimTypes.Role, user.Role) }; user.LastLoginDate = DateTime.UtcNow; user.ModifiedDate = DateTime.UtcNow; await _dbService.Users.UpdateAsync(user); var identity = new ClaimsIdentity(claims, "Basic"); HttpContext.User = new ClaimsPrincipal(identity); return(Ok(new { Token = _authService.GenerateJwtToken(identity), User = new { Username = user.Username } })); }
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel) { var validation = new SignInModelValidator().Valid(signInModel); if (!validation.Success) { return(new ErrorDataResult <TokenModel>(validation.Message)); } var signedInModel = await UserRepository.SignInAsync(signInModel); if (!SignInService.Validate(signedInModel, signInModel)) { return(new ErrorDataResult <TokenModel>(Texts.LoginPasswordInvalid)); } var userLogModel = new UserLogModel(signedInModel.UserId, LogType.SignIn); await UserLogApplicationService.AddAsync(userLogModel); await UnitOfWork.SaveChangesAsync(); var tokenModel = SignInService.CreateToken(signedInModel); return(new SuccessDataResult <TokenModel>(tokenModel)); }
public async Task <IActionResult> ResetPassword(SignInModel model) { if (!string.IsNullOrEmpty(model.Token)) { var principal = _authService.VerifyPasswordResetToken(model.Token); if (principal == null) { return(BadRequest("Invalid token.")); } var user = await _dbService.Users.FindByUsernameAsync(principal.Identity.Name); user.Password = model.Password; await _dbService.Users.UpdateAsync(user); } else { var user = await _dbService.Users.FindByUsernameAsync(model.Username); if (user == null) { return(BadRequest("Invalid username.")); } var token = _authService.GeneratePasswordResetToken(user.Username); // send email } return(Ok()); }
public IActionResult SignIn(SignInModel signInModel, string returnUrl) { var domainModel = signInModel.ToModel(); if (ModelState.IsValid) { var response = _service.SignIn(domainModel.Username, domainModel.Password, signInModel.IsPersistent, HttpContext); if (response.Success) { if (returnUrl == null) { return(RedirectToAction("Overview", "Movies")); } else { return(Redirect(returnUrl)); } } else { ModelState.AddModelError("", response.Message); //return RedirectToAction("SignIn", new { ErrorMessage = response.Message }); } } return(View(signInModel)); }
public async Task <IActionResult> Login(SignInModel signInModel, string returnUrl) { if (ModelState.IsValid) { var result = await _accountRepository.PasswordSignInAsync(signInModel); if (result.Succeeded) { if (!string.IsNullOrEmpty(returnUrl)) { return(LocalRedirect(returnUrl)); } return(RedirectToAction("Index", "Home")); } if (result.IsNotAllowed) { ModelState.AddModelError("", "Not allowed to login"); } else { ModelState.AddModelError("", "Invalid Username and Password"); } } return(View()); }
public async Task <IResult <TokenModel> > SignInAsync(SignInModel model) { var failResult = Result <TokenModel> .Fail("Invalid login or password!"); var validation = await new SignInModelValidator().ValidationAsync(model); if (validation.Failed) { return(failResult); } var auth = await _authRepository.GetByLoginAsync(model.Login); if (auth is null) { return(failResult); } var password = _hashService.Create(model.Password, auth.Salt); if (auth.Password != password) { return(failResult); } return(CreateToken(auth)); }
public async Task <AuthResultModel> AuthorizeUser(SignInModel model) { var user = await _userManager.Users.Include(u => u.UserRoles).ThenInclude(ur => ur.Role) .FirstOrDefaultAsync(u => u.UserName == model.Username); if (user == null) { throw new UserNotAuthorizedException("Username or password is incorrect"); } if (!await _userManager.CheckPasswordAsync(user, model.Password)) { throw new UserNotAuthorizedException("Username or password is incorrect"); } user.RefreshToken = GenerateRefreshToken(); await _userManager.UpdateAsync(user); var roles = user.UserRoles?.Select(_ => _.Role.Name).ToList(); var userPermissions = user.UserRoles?.SelectMany(_ => _.Role.Permissions.Split(",")).ToList(); var resultModel = new AuthResultModel { Token = await GenerateUserToken(user), Expire = DateTime.UtcNow.AddDays(7), UserId = user.Id, RefreshToken = user.RefreshToken, Roles = roles, Permissions = userPermissions, }; return(resultModel); }
public SignInResponse SignIn(SignInModel userInfo) { SignInResponse resp = new SignInResponse(); try { resp = _IAuthRepository.SignIn(userInfo); if (resp != null && resp.userInfo != null) { resp.status = resp.status; resp.message = resp.message; resp.token = _IAuthRepository.BuildToken("Sign In", resp.userInfo.accountId); resp.userInfo.avatar = null; resp.userInfo.remember = userInfo.remember; } return(resp); } catch (Exception ex) { _ILogs.LogError("SignIn Service: ", ex.Message.ToString(), ex.StackTrace); } return(null); }
public async Task <IActionResult> Login(SignInModel signInModel, string returnUrl) { if (ModelState.IsValid) { var result = await _accountRepository.PasswordSignInAsync(signInModel); if (result.Succeeded) { if (!string.IsNullOrEmpty(returnUrl)) { return(LocalRedirect(returnUrl)); } return(RedirectToAction("Index", "Home")); } if (result.IsNotAllowed) { ModelState.AddModelError("", "Not allowed to Login!"); } else if (result.IsLockedOut) { ModelState.AddModelError("", "Account Blocked for 5 minutes!"); } else { ModelState.AddModelError("", "Invalid credertials"); } } return(View(signInModel)); }
public async Task <IActionResult> Login(SignInModel signInModel, string returnUrl) { if (ModelState.IsValid) { var result = await _accountRepository.SignInAsync(signInModel); if (result.Succeeded) { if (!string.IsNullOrEmpty(returnUrl)) { return(LocalRedirect(returnUrl)); } return(RedirectToAction("GetAllBooks", "Book")); } if (result.IsNotAllowed) { ModelState.AddModelError("", "Not Allowed"); } else { ModelState.AddModelError("", "Invalid Credentials"); } } return(View()); }
async void SignInButton_Clicked(object sender, EventArgs e) { var errorMessage = ""; var valid = ValidateLoginInput(out errorMessage); if (valid) { if (CrossConnectivity.Current.IsConnected) { ShowBusy(MessageHelper.LoggingIn); TryExecute(async() => { var payload = new SignInModel { Username = loginuserName.Text.Trim(), Password = loginpassword.Text.Trim(), ApartmentName = ApartmentName.Text.Trim() }; var task = await SignInTask(payload); HideBusy(); }); } else { UserDialogs.Instance.ErrorToast(MessageHelper.NoInternet); } } else { await DisplayAlert(MessageHelper.InvalidInput, errorMessage, "OK"); } }
public async Task <IActionResult> SignIn(SignInModel signInModel, string returnUrl = null) { if (ModelState.IsValid) { Response response = await AuthService.SignIn(signInModel.Username, signInModel.Password, HttpContext); if (response.IsSuccessful) { if (!String.IsNullOrEmpty(returnUrl)) { return(Redirect(returnUrl)); } else { return(RedirectToAction("Overview", "Blog")); } } else { ModelState.AddModelError(string.Empty, response.Message); return(View(signInModel)); } } else { return(View(signInModel)); } }
async Task <TokenModel> SignInTask(SignInModel payload) { var userService = DependencyService.Get <ILoginService>(); var result = await userService.SignIn(payload); if (result.Success == true) { App.SetAuth(result); var json = JsonConvert.SerializeObject(result); var service = DependencyService.Get <ILoginService>(); await service.SaveUserData(json); await service.SaveAppartment(ApartmentName.Text.Trim()); var MainPage = new RootPage(); await Navigation.PushModalAsync(MainPage); MessageHelper.ShowToast(ToastNotificationType.Success, MessageHelper.LoggedSucess); } else { MessageHelper.ShowToast(ToastNotificationType.Error, result.ErrorMessage); } return(result); }
public async Task <IActionResult> SignIn(bool isRememberMeActivated, [FromBody] SignInModel loginData) { var userModel = await _accountService.SignInAsync(loginData); var tokenModel = new TokenModel(); if (userModel.Errors.Any()) { tokenModel.Errors = userModel.Errors; return(Ok(tokenModel)); } double tokenLifeTime = _jwtConfig.GetValue <double>("AccessTokenLifeTime"); string secretKey = _jwtConfig.GetValue <string>("SecretKey"); tokenModel.AccessToken = _jwtHelper.GenerateToken(userModel, tokenLifeTime, secretKey, true); tokenLifeTime = isRememberMeActivated ? _jwtConfig.GetValue <double>("RefreshTokenLifeTimeLong") : _jwtConfig.GetValue <double>("RefreshTokenLifeTime"); tokenModel.RefreshToken = _jwtHelper.GenerateToken(userModel, tokenLifeTime, secretKey, false); return(Ok(tokenModel)); }
public IActionResult SignIn(SignInModel signInModel, string returnUrl) { if (ModelState.IsValid) { var response = _authService.SignIn(signInModel.Username, signInModel.Password, signInModel.IsPersistent, HttpContext); if (response.IsSuccessful) { if (returnUrl == null) { return(RedirectToAction("Overview", "Movies")); } else { return(Redirect(returnUrl)); } } else { ModelState.AddModelError("", response.Message); return(View(signInModel)); } } else { return(View(signInModel)); } }
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel) { var validation = new SignInModelValidator().Validate(signInModel); if (validation.Failed) { return(DataResult <TokenModel> .Fail(validation.Message)); } var signedInModel = await _userRepository.SignInAsync(signInModel); validation = _signInService.Validate(signedInModel, signInModel); if (validation.Failed) { return(DataResult <TokenModel> .Fail(validation.Message)); } var userLogModel = new UserLogModel(signedInModel.Id, LogType.SignIn); await _userLogApplicationService.AddAsync(userLogModel); var tokenModel = _signInService.CreateToken(signedInModel); return(DataResult <TokenModel> .Success(tokenModel)); }
public async Task <IActionResult> SignIn(SignInModel model, string returnUrl = null) { if (ModelState.IsValid) { var isSignedIn = await AuthService.SignInAsync(model.Username, model.Password, HttpContext); if (isSignedIn) { if (!String.IsNullOrEmpty(returnUrl)) { return(Redirect(returnUrl)); } else { return(RedirectToAction("Overview", "Recipes")); } } else { ModelState.AddModelError(string.Empty, "Username or password is incorrect"); return(View(model)); } } return(View(model)); }
public async Task <IDataResult <SignedInModel> > SignInAsync(SignInModel signInModel) { var validation = new SignInModelValidator().Valid(signInModel); if (!validation.Success) { return(new ErrorDataResult <SignedInModel>(validation.Message)); } var userDomain = UserDomainFactory.Create(signInModel); userDomain.SignIn(); signInModel = userDomain.Map <SignInModel>(); var signedInModel = await UserRepository.SignInAsync(signInModel).ConfigureAwait(false); validation = new SignedInModelValidator().Valid(signedInModel); if (!validation.Success) { return(new ErrorDataResult <SignedInModel>(validation.Message)); } await AddUserLogAsync(signedInModel.UserId, LogType.SignIn).ConfigureAwait(false); return(new SuccessDataResult <SignedInModel>(signedInModel)); }
public ActionResult ComputeSignIn(SignInModel model) { if (CurrentUser != null) { return(RedirectToAction("Index", "Home")); } if (!ModelState.IsValid) { return(View("SignIn", model)); } Account account = DataContext.Accounts.FirstOrDefault( ac => ac.Login == model.Login && ac.Hash == model.Password.MD5()); if (account == null) { ModelState.AddModelError("", "Invalid login or password"); if (model.BreadcrumbModel == null) { model.BreadcrumbModel = new BreadcrumbModel(Url.Action("SignIn", "Account", null, Request.Url.Scheme)); } return(View("SignIn", model)); } DoLogin(account); return(RedirectToAction("Index", "Home")); }
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel) { var validation = new SignInModelValidator().Valid(signInModel); if (!validation.Success) { return(ErrorDataResult <TokenModel>(validation.Message)); } UserDomainService.GenerateHash(signInModel); var signedInModel = await UserRepository.SignInAsync(signInModel); validation = new SignedInModelValidator().Valid(signedInModel); if (!validation.Success) { return(ErrorDataResult <TokenModel>(validation.Message)); } var addUserLogModel = new AddUserLogModel(signedInModel.UserId, LogType.SignIn); await UserLogApplicationService.AddAsync(addUserLogModel); var tokenModel = UserDomainService.GenerateToken(signedInModel); return(SuccessDataResult(tokenModel)); }
public ActionResult Index(SignInModel model, string returnUrl) { HttpContext.Session["facilityDateHash"] = null; if (ModelState.IsValid) { string errorMessage = ""; string hash = ""; if (userRepository.ValidateUser(model.Email, model.Password, ref errorMessage, ref hash)) { FormsAuthentication.SetAuthCookie(model.Email, model.RememberMe); HttpContext.Session["facilityDateHash"] = hash; HttpContext.Session["email"] = model.Email; if (UrlSafe(returnUrl)) { return(Redirect(returnUrl)); } return(RedirectToAction("Index", "Home")); } ModelState.AddModelError("", errorMessage); } return(View(model)); }
// shows the signin screen public ActionResult SignIn(string returnUrl, bool mobile=false) { // you can call AuthenticationHelper.GetRelyingPartyDetailsFromReturnUrl to get more information about the requested relying party var vm = new SignInModel() { ReturnUrl = returnUrl, ShowClientCertificateLink = ConfigurationRepository.Global.EnableClientCertificateAuthentication }; if (mobile) vm.IsSigninRequest = true; return View(vm); }
public ActionResult SignIn(SignInModel model, string returnUrl) { if (ModelState.IsValid) { if (_userRepository.ValidateUser(model.UserName, model.Password)) { return SetPrincipalAndRedirect(model.UserName, AuthenticationMethods.Password, returnUrl, model.EnableSSO, _configurationRepository.Configuration.SsoCookieLifetime); } } ModelState.AddModelError("", "Incorrect credentials or no authorization."); ViewBag.ShowClientCertificateLink = _configurationRepository.Configuration.EnableClientCertificates; return View(model); }
public ActionResult SignIn(SignInModel model) { if (ModelState.IsValid) { if (UserRepository.ValidateUser(model.UserName, model.Password)) { // establishes a principal, set the session cookie and redirects // you can also pass additional claims to signin, which will be embedded in the session token return SignIn( model.UserName, AuthenticationMethods.Password, model.ReturnUrl, model.EnableSSO, ConfigurationRepository.Global.SsoCookieLifetime); } } ModelState.AddModelError("", Resources.AccountController.IncorrectCredentialsNoAuthorization); model.ShowClientCertificateLink = ConfigurationRepository.Global.EnableClientCertificateAuthentication; return View(model); }