public BaseResponseModel SignIn(SignInInputModel inputModel) { var vm = new AuthResponseModel(); var user = UserService.Authenticate(inputModel.Email, inputModel.Password); if (user != null) { _auth.DoAuth(inputModel.Email, inputModel.RememberMe); vm.Success = true; vm.Token = user.AuthToken.Token; vm.Expires = user.AuthToken.Expires; } else { vm.Errors.Add("Invalid email or password"); LogService.CreateLog(new Log { Category = LogCategory.Security, IpAddress = GetClientIp(ControllerContext.Request), Level = LogLevel.Info, Message = "Authentication failed using email: " + inputModel.Email }); } return(vm); }
private async Task <SignInViewModel> BuildSignInViewModelAsync(SignInInputModel model) { var viewModel = await BuildSignInViewModelAsync(model.ReturnUrl); viewModel.Email = model.Email; viewModel.RememberMe = model.RememberMe; return(viewModel); }
private async Task <SignInViewModel> CreateSigninModelAsync(SignInInputModel signIn) { var model = await CreateSigninModelAsync(signIn.ReturnUrl); model.Email = signIn.Email; model.RememberMe = signIn.RememberMe; return(model); }
public async Task <IActionResult> SignIn([FromBody] SignInInputModel signInInputModel) { var retorno = await _userService.SignIn(signInInputModel); if (retorno == null) { return(NotFound()); } return(Ok(BuildToken(retorno))); }
public bool Is_Customer_Sign_Input_Valid(SignInInputModel CustomerSignInInput) { string passwordPattern = @"^[^\s^<>]*$"; string emailPattern = @"[\w-]+@([\w-]+\.)+[\w-]+"; Regex passwordRegex = new Regex(passwordPattern); Regex emailRegex = new Regex(emailPattern); if (emailRegex.IsMatch(CustomerSignInInput.EmailAddress) && passwordRegex.IsMatch(CustomerSignInInput.Password) && CustomerSignInInput.EmailAddress != null && CustomerSignInInput.Password != null) { return(true); } return(false); }
public IActionResult SignIn([FromBody] SignInInputModel inputModel) { if (!ModelState.IsValid) { BadRequest(); } string passwordHash = _cryptographyService.GetHashString(inputModel.Password); var user = _userService.GetUser(inputModel.EmailAddress, passwordHash); if (user == null) { NotFound("User not found"); } return(Ok(user)); }
public async Task <SignInViewModel> SignIn(SignInInputModel signInInputModel) { SignInViewModel ret = null; var user = await _userRepository.SignIn(signInInputModel.Email, signInInputModel.Password); if (user != null) { AddressViewModel address = null; var person = _mapper.Map <Person, PersonViewModel>(user.Person); if (user.Person.Address.Count() > 0) { address = _mapper.Map <Address, AddressViewModel>(user.Person.Address.FirstOrDefault()); } ret = new SignInViewModel(null, DateTime.Now, person, address); } return(ret); }
public ActionResult SignIn(SignInInputModel inputModel) { if (ModelState.IsValid) { if (!User.Identity.IsAuthenticated) { var saltedInputPassword = HashUtilities.GetPasswordHash(inputModel.Password, SiteSettings.PasswordSalt); if (saltedInputPassword == SiteSettings.PasswordHash && inputModel.Username == SiteSettings.Username) { FormsAuthentication.SetAuthCookie(inputModel.Username, inputModel.RememberMe); return Redirect(inputModel.ReturnUrl); } ModelState.AddModelError("Username", "Username & Password are not correct"); ModelState.AddModelError("Password", "Username & Password are not correct"); } } return SignIn(); }
public async Task <IActionResult> SignIn(SignInInputModel model, string button) { var context = await _interactionService.GetAuthorizationContextAsync(model.ReturnUrl); if (button != "signin") { if (context is not null) { await _interactionService.DenyAuthorizationAsync(context, AuthorizationError.AccessDenied); if (context.IsNativeClient()) { return(this.LoadingPage("Redirect", model.ReturnUrl)); } return(Redirect(model.ReturnUrl)); } else { return(Redirect("/")); } } if (ModelState.IsValid) { var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure : true); if (result.Succeeded) { var user = await _userManager.FindByEmailAsync(model.Email); await _eventService.RaiseAsync(new UserLoginSuccessEvent(user.Email, user.Id, user.UserName, clientId : context?.Client.ClientId)); if (context is not null) { if (context.IsNativeClient()) { return(this.LoadingPage("Redirect", model.ReturnUrl)); } return(Redirect(model.ReturnUrl)); } if (Url.IsLocalUrl(model.ReturnUrl)) { return(Redirect(model.ReturnUrl)); } else if (string.IsNullOrEmpty(model.ReturnUrl)) { return(Redirect("~/")); } else { throw new Exception("Invalid return URL"); } } await _eventService.RaiseAsync(new UserLoginFailureEvent(model.Email, "Invalid credentials", clientId : context?.Client.ClientId)); ModelState.AddModelError(string.Empty, AccountOptions.InvalidCredentialsErrorMessage); } var viewModel = await BuildSignInViewModelAsync(model); ViewData["ReturnUrl"] = model.ReturnUrl; return(View(viewModel)); }
public async Task <IActionResult> Signin([FromForm] SignInInputModel model, [FromForm] string button) { var context = await interactions.GetAuthorizationContextAsync(model.ReturnUrl); if ("signin" != button) { logger.LogDebug("Signin executing"); if (null != context) { await interactions.GrantConsentAsync(context, ConsentResponse.Denied); if (await clientStore.IsPkceClientAsync(context.ClientId)) { return(View("Redirect", new RedirectModel { RedirectUrl = model.ReturnUrl })); } return(Redirect(model.ReturnUrl)); } return(Redirect("~/")); } if (ModelState.IsValid) { var result = await mediator.Send( new GetCustomerQuery(model.Email, model.Password), HttpContext.RequestAborted ); if (result.IsFailed) { return(View()); } if (result.IsNotAllowed) { return(View()); } if (result.IsLockedOut) { return(View()); } if (result.RequiresTwoFactor) { return(View()); } if (result.IsSucceeded) { var customer = result.Customer; await eventService.RaiseAsync(new UserLoginSuccessEvent( IdentityServerConstants.LocalIdentityProvider, customer.Id.ToString(), customer.Email, customer.UserName) ); await mediator.Send( new SigninCommand(customer, model.RememberMe), HttpContext.RequestAborted ); if (null != context) { if (await clientStore.IsPkceClientAsync(context.ClientId)) { return(View("Redirect", new RedirectModel { RedirectUrl = model.ReturnUrl })); } return(Redirect(model.ReturnUrl)); } if (Url.IsLocalUrl(model.ReturnUrl)) { return(Redirect(model.ReturnUrl)); } if (String.IsNullOrEmpty(model.ReturnUrl)) { return(Redirect("~/")); } var uri = new Uri(model.ReturnUrl); if (uri.IsAbsoluteUri) { return(Redirect(model.ReturnUrl)); } throw new Exception("Invalid redirect url"); } } //var invalidCredentials = localizer.InvalidCredentials(context?.UiLocales); var invalidCredentials = "Invalid credentials"; await eventService.RaiseAsync(new UserLoginFailureEvent(model.Email, invalidCredentials)); ModelState.AddModelError(String.Empty, invalidCredentials); return(View(await CreateSigninModelAsync(model))); }
public Customer CustomerLoggingIn(SignInInputModel CustomerSignInInput) { var result = db.Customers.Where(customer => customer.EmailAddress == CustomerSignInInput.EmailAddress && customer.Password == CustomerSignInInput.Password).First(); return(result); }
public string LoggedInUser(SignInInputModel CustomerSignInInput) { Customer customer = CustomerRepository.CustomerLoggingIn(CustomerSignInInput); return(customer.FirstName + "," + customer.Id.ToString()); }
public bool IsCustomerSignInExist(SignInInputModel CustomerSignInInput) { var result = db.Customers.Where(customer => customer.EmailAddress == CustomerSignInInput.EmailAddress && customer.Password == CustomerSignInInput.Password).ToList(); return(result.Count > 0); }