public async Task SetupAsync() { _evnt = new EventViewModel { Title = "Title event", Description = "Test event", Start = "11:00", End = "14:27", Date = "2016-02-01" }; var userViewModel = new LoginViewModel { Email = "*****@*****.**", Password = "******", RememberMe = false }; var context = new DataContext(); var manager = new UserManager(new UserStore(context)); var user = await manager.FindAsync(userViewModel.Email, userViewModel.Password); if (user == null) { await manager.CreateAsync(new User { Email = userViewModel.Email, UserName = userViewModel.Email }, userViewModel.Password); } _calendarController = new CalendarController(context); var mockCp = new Mock<IClaimsPrincipal>(); if (user != null) mockCp.SetupGet(cp => cp.UserId).Returns(user.Id); _calendarController.CurrentUser = mockCp.Object; var mockAuthenticationManager = new Mock<IAuthenticationManager>(); mockAuthenticationManager.Setup(am => am.SignOut()); mockAuthenticationManager.Setup(am => am.SignIn()); _calendarController.AuthenticationManager = mockAuthenticationManager.Object; }
public async Task<ActionResult> Login(LoginViewModel model) { // password for jwmcpeak is asdlfkf@RAG04 if (!ModelState.IsValid) { return View(model); } var userStore = new UserStore<IdentityUser>(); var userManager = new UserManager<IdentityUser>(userStore); var user = await userManager.FindAsync(model.Username, model.Password); if (user == null) { ModelState.AddModelError(string.Empty, "The user with the supplied credentials does not exist."); return View(model); } var authManager = HttpContext.GetOwinContext().Authentication; var userIdentity = await userManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); authManager.SignIn(new AuthenticationProperties { IsPersistent = model.RememberMe }, userIdentity); return RedirectToAction("index", "home"); }
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] {"*"}); try { using (var userManager = new UserManager<User>(new UserStore<User>(new ElearningDbContext()))) { var user = await userManager.FindAsync(context.UserName, context.Password); if (user == null) { context.SetError("invaild_grant", "The user name or password is incorrect"); return; } } } catch (Exception ex) { var a = ex; throw; } var identity = new ClaimsIdentity("JWT"); identity.AddClaim(new Claim(ClaimTypes.Name, context.UserName)); identity.AddClaim(new Claim("sub", context.UserName)); identity.AddClaim(new Claim(ClaimTypes.Role, "user")); var properties = new AuthenticationProperties(new Dictionary<string, string> { { "audience", context.ClientId ?? string.Empty } }); var ticket = new AuthenticationTicket(identity, properties); context.Validated(ticket); }
public async Task<string> GetAuthKey(string username, string password) { var store = new ApplicationDbContext(); var UserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(store)); var user =await UserManager.FindAsync(username, password); var key=Guid.NewGuid().ToString(); user.Logins.Add(new IdentityUserLogin { LoginProvider="app",ProviderKey=key,UserId=user.Id}); store.SaveChanges(); return key; }
/// <summary> /// Invoked after the LTI request has been authenticated so the application can sign in the application user. /// </summary> /// <param name="context">Contains information about the login session as well as the LTI request.</param> /// <param name="claims">Optional set of claims to add to the identity.</param> /// <returns>A <see cref="Task"/> representing the completed operation.</returns> public static async Task OnAuthenticated(LtiAuthenticatedContext context, IEnumerable<Claim> claims = null) { // Find existing pairing between LTI user and application user var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new LtiDb())); var loginProvider = string.Join(":", new[] { context.Options.AuthenticationType, context.LtiRequest.ConsumerKey }); var providerKey = context.LtiRequest.UserId; var login = new UserLoginInfo(loginProvider, providerKey); var user = await userManager.FindAsync(login); if (user == null) { var usernameContext = new LtiGenerateUserNameContext(context.OwinContext, context.LtiRequest); await context.Options.Provider.GenerateUserName(usernameContext); if (string.IsNullOrEmpty(usernameContext.UserName)) { return; } user = await userManager.FindByNameAsync(usernameContext.UserName); if (user == null) { user = new ApplicationUser { UserName = usernameContext.UserName }; var result = await userManager.CreateAsync(user); if (!result.Succeeded) { return; } } // Save the pairing between LTI user and application user await userManager.AddLoginAsync(user.Id, login); } // Create the application identity, add the LTI request as a claim, and sign in var identity = await userManager.CreateIdentityAsync(user, context.Options.SignInAsAuthenticationType); identity.AddClaim(new Claim(context.Options.ClaimType, JsonConvert.SerializeObject(context.LtiRequest, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }), ClaimValueTypes.String, context.Options.AuthenticationType)); if (claims != null) { foreach (var claim in claims) { identity.AddClaim(claim); } } context.OwinContext.Authentication.SignIn(new AuthenticationProperties { IsPersistent = false }, identity); // Redirect to original URL so the new identity takes affect context.RedirectUrl = context.LtiRequest.Url.ToString(); }
// GET: ClaimsIdentityFactory public async Task<ActionResult> Index(LoginViewModel model, string returnUrl) { var context = new MyDbContext(); var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context)); userManager.ClaimsIdentityFactory = new MyClaimsIdentityFactory<ApplicationUser>(); // Create a User to SignIn var user = await userManager.FindAsync(model.UserName, model.Password); //SignIn the User by generating a ClaimsIdentity var claimsIdentity = await userManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); // This claimsIdentity should have a claim called LastLoginTime var authManager = HttpContext.GetOwinContext().Authentication; authManager.SignIn(claimsIdentity); return RedirectToLocal(returnUrl); }
public async void CreatesFindsAndDeletes() { var username = "******"; var user = new IdentityUser(username); Console.WriteLine("GUID: {0}", user.Id); var password = "******"; var sut = new UserManager(); await sut.CreateAsync(user, password); var actualUser = await sut.FindAsync(username, password); Assert.IsNotNull(actualUser); Assert.AreEqual(user.Id, actualUser.Id); await sut.DeleteAsync(user); }
public async Task <IHttpActionResult> LoginJwt(LoginModel loginModel) { var user = await UserManager.FindAsync(loginModel.UserName, loginModel.Password); if (user == null) { return(Ok(new ResponseBase <JObject> { statusCode = 400, userMessage = "Invalid email address or password.", devMessage = "Invalid email address or password.", })); } var token = TokenManager.GenerateToken(user.UserName); return(Ok(token)); }
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)); } ModelState.AddModelError("", "Invalid username or password."); } // If we got this far, something failed, redisplay form return(View(model)); }
public virtual async Task <ExternalAuthenticateResult> AuthenticateExternalAsync(string subject, ExternalIdentity externalUser) { if (externalUser == null) { throw new ArgumentNullException("externalUser"); } var user = await userManager.FindAsync(new UserLoginInfo(externalUser.Provider.Name, externalUser.ProviderId)); if (user == null) { return(await ProcessNewExternalAccountAsync(externalUser.Provider.Name, externalUser.ProviderId, externalUser.Claims)); } else { return(await ProcessExistingExternalAccountAsync(user.Id, externalUser.Provider.Name, externalUser.ProviderId, externalUser.Claims)); } }
public async Task <ActionResult> Login(LoginViewModel details, string returnUrl) { if (ModelState.IsValid) { AppUser user = await UserManager.FindAsync(details.Name, details.Password); if (user == null) { ModelState.AddModelError("", "Invalid name or password."); } // else { //If the FindAsync method does return an AppUser object, //then I need to create the cookie that the browser will send in subsequent requests to show they are authenticated. H ClaimsIdentity ident = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); ident.AddClaims(LocationClaimsProvider.GetClaims(ident)); ident.AddClaims(ClaimsRoles.CreateRolesFromClaims(ident)); //I will use Email-type claim to identify users (I did this in Global.asax/Application_Start()), //external authority will give me this claim //but LOCAL AUTHORIRY will not, so I manually create one ident.AddClaim(new Claim("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress", user.Email)); //invalidate any existing authentication cookies and create the new one AuthManager.SignOut(); AuthManager.SignIn( new AuthenticationProperties { //Keep the cookie persistent, //the user doesn't have to authenticate again when starting a new session IsPersistent = false }, ident); // Migrate the user's shopping cart Session["CartId"] = user.UserName; MigrateShoppingCart(user.UserName); } } ViewBag.returnUrl = returnUrl; return(View(details)); }
public async Task <IHttpActionResult> Login(Auth auth) { try { var appUser = await _userManager.FindAsync(auth.UserName, auth.Password); if (appUser != null && appUser.Status == Enum.Status.Active) { if (appUser.IsInRole(Enum.Role.Dealer)) { var dealer = _dealerServices.GetByUserId(appUser.Id); if (!dealer.Enable) { return(Content(HttpStatusCode.Forbidden, "This dealer is disabled")); } } var isRememberMe = true; Authentication.SignOut(DefaultAuthenticationTypes.ApplicationCookie); Authentication.SignIn(new AuthenticationProperties { IsPersistent = isRememberMe }, await appUser.GenerateUserIdentityAsync(_userManager, DefaultAuthenticationTypes.ApplicationCookie, appUser)); return(Ok(new { data = new { user = appUser, token = Guid.NewGuid().ToString() } })); } return(Ok(new { data = new { error = "error" } })); } catch (Exception ex) { return(BadRequest(ex.ToString())); } }
public async Task <ActionResult> ExternalLoginCallback(string returnUrl) { var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync(); if (loginInfo == null) { return(RedirectToAction("Login")); } var user = await UserManager.FindAsync(loginInfo.Login); // Logar caso haja um login externo e já esteja logado neste provedor de login var result = await SignInManager.ExternalSignInAsync(loginInfo, isPersistent : false); switch (result) { case SignInStatus.Success: var userext = UserManager.FindByEmailAsync(user.Email); await SignInAsync(userext.Result, false); return(RedirectToLocal(returnUrl)); case SignInStatus.LockedOut: return(View("Lockout")); case SignInStatus.RequiresVerification: return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl })); case SignInStatus.Failure: default: // Se ele nao tem uma conta solicite que crie uma var externalIdentity = HttpContext.GetOwinContext().Authentication.GetExternalIdentityAsync(DefaultAuthenticationTypes.ExternalCookie); var email = externalIdentity.Result.Claims.FirstOrDefault(c => c.Type == "urn:facebook:email").Value; var firstName = externalIdentity.Result.Claims.FirstOrDefault(c => c.Type == "urn:facebook:first_name").Value; var lastName = externalIdentity.Result.Claims.FirstOrDefault(c => c.Type == "urn:facebook:last_name").Value; ViewBag.ReturnUrl = returnUrl; ViewBag.LoginProvider = loginInfo.Login.LoginProvider; return(View("ExternalLoginConfirmation", new ExternalLoginConfirmationViewModel { Email = loginInfo.Email, LastName = lastName, Name = firstName })); } }
public async Task <ActionResult> Create(LoginViewModel loginModel, string returnAddress) { if (ModelState.IsValid) { UserManager <ApplicationUser> userManager = new UserManager <ApplicationUser>(new UserStore()); var user = await userManager.FindAsync(loginModel.UserName, loginModel.Password); if (user != null) { HttpContext.GetOwinContext().Authentication.SignOut( DefaultAuthenticationTypes.ExternalCookie); var identity = await userManager.CreateIdentityAsync( user, DefaultAuthenticationTypes.ApplicationCookie); HttpContext.GetOwinContext().Authentication.SignIn( new AuthenticationProperties() { IsPersistent = loginModel.RememberMe }, identity); if (Url.IsLocalUrl(returnAddress)) { return(Redirect(returnAddress)); } else { return(RedirectToAction("Index", "Orders")); } } else { ModelState.AddModelError( string.Empty, "Invalid user name or password."); } } return(View(loginModel)); }
public async Task <ActionResult> LogIn(UsuarioViewModel model) { if (!ModelState.IsValid) { return(View()); } var user = await userManager.FindAsync(model.Email, model.Password); if (user != null) { var identity = await userManager.CreateIdentityAsync( user, DefaultAuthenticationTypes.ApplicationCookie); GetAuthenticationManager().SignIn(identity); return(Redirect(GetRedirectUrl(model.ReturnUrl))); } ModelState.AddModelError("", "Usuário e/ou Senha inválidos"); return(View()); }
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { var userStore = new UserStore <ApplicationUser>(new ApplicationDbContext()); var manager = new UserManager <ApplicationUser>(userStore); var user = await manager.FindAsync(context.UserName, context.Password); if (user != null) { var identity = new ClaimsIdentity(context.Options.AuthenticationType); identity.AddClaim(new Claim("Username", user.UserName)); identity.AddClaim(new Claim("Email", user.Email)); identity.AddClaim(new Claim("LoggedOn", DateTime.Now.ToString())); context.Validated(identity); } else { return; } }
public async Task <IdentityResult> SignInUserLoginAsync(LoginViewModel model) { using (var scope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions { IsolationLevel = IsolationLevel.RepeatableRead }, TransactionScopeAsyncFlowOption.Enabled)) { var result = IdentityResult.Failed(); try { var password = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(model.Password)); var user = await UserManager.FindAsync(model.UserName, password); if (user != null) { result = IdentityResult.Success; //var user = new //{ // UserId = Guid.NewGuid().ToString("n"), // UserName = model.UserName //}; //var identity = new ClaimsIdentity(DefaultAuthenticationTypes.ApplicationCookie, ClaimsIdentity.DefaultNameClaimType, ClaimsIdentity.DefaultRoleClaimType); //identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.UserId, ClaimValueTypes.String, DefaultAuthenticationTypes.ApplicationCookie)); //identity.AddClaim(new Claim(ClaimTypes.Name, user.UserName, ClaimValueTypes.String, DefaultAuthenticationTypes.ApplicationCookie)); //AuthenticationManager.SignIn(new AuthenticationProperties { IsPersistent = model.IsPersistent }, identity); //return RedirectToLocal(returnUrl); //var claimsIdentity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie); await SignInManager.SignInAsync(user, isPersistent : model.IsPersistent, rememberBrowser : false); } scope.Complete(); } catch (Exception ex) { result = IdentityResult.Failed(ex.Message); } finally { } return(result); } }
public async Task <ActionResult> IniciarSesion(LoginViewModel model, string returnUrl) { if (ModelState.IsValid) { var user = await UserManager.FindAsync(model.UserName, model.Password); if (user != null) { await SignInAsync(user, model.RememberMe); } else { ModelState.AddModelError("", "Usuario no registrado."); } } // If we got this far, something failed, redisplay form return(View(model)); }
public async Task FindAsync_ShouldReturnNull_WhenGivenCredentialsAreNotValid() { // arrange var user = new ApplicationUser { Username = Username, Password = Password }; _userRepository.GetUserAsync(Username) .Returns(user); _passwordHasher.VerifyHashedPassword(Arg.Any <string>(), Arg.Any <string>()) .ReturnsForAnyArgs(false); // act var userManager = new UserManager(_userRepository, _passwordHasher); var result = await userManager.FindAsync(Username, Password); // assert result.Should().BeNull(); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (!ModelState.IsValid) { return View(model); } var userStore = new UserStore<ApplicationUser>(new DataContext()); var userManager = new UserManager<ApplicationUser>(userStore); var user = await userManager.FindAsync(model.Email, model.Password); if (user != null) { ModelState.AddModelError(string.Empty, "Пользователь существует"); return View(model); } user = new ApplicationUser { UserName = model.Email, Email = model.Email }; await userManager.CreateAsync(user, model.Password); return RedirectToAction("Index", "Home"); }
public async Task <ActionResult> GoogleLoginCallback(string returnUrl) { ExternalLoginInfo loginInfo = await AuthManager.GetExternalLoginInfoAsync(); AppUser user = await UserManager.FindAsync(loginInfo.Login); //檢查user 是否為第一次登入,若為是的話則回傳null if (user == null) { user = new AppUser { Email = loginInfo.Email, UserName = loginInfo.DefaultUserName, CityID = 1, CountryID = 1 }; //為該user 創建一個新的資料存到DB IdentityResult result = await UserManager.CreateAsync(user); if (!result.Succeeded) { return(View("Error", result.Errors)); } else { result = await UserManager.AddLoginAsync(user.Id, loginInfo.Login); if (!result.Succeeded) { return(View("Error", result.Errors)); } } } ClaimsIdentity ident = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); //ident.AddClaims(loginInfo.ExternalIdentity.Claims); //複製由Google 提供的Claims ident.AddClaims(ClaimsRoles.CreateRoleForGoogle()); AuthManager.SignIn(new AuthenticationProperties { IsPersistent = false }, ident); return(Redirect(returnUrl ?? "/")); }
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { var allowedOrigin = "*"; context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { allowedOrigin }); ApplicationUser user = await manager.FindAsync(context.UserName, context.Password); if (user == null) { context.SetError("invalid_grant", "The user name or password is incorrect."); return; } ClaimsIdentity oAuthIdentity = await manager.CreateIdentityAsync(user, "JWT"); var ticket = new AuthenticationTicket(oAuthIdentity, null); context.Validated(ticket); }
public async Task <User> GetUser(string userName, string password) { ApplicationUser applicationUser = await UserManager.FindAsync(userName, password); if (applicationUser != null) { return(new User() { FirstName = applicationUser.UserProfile.FirstName, LastName = applicationUser.UserProfile.LastName, Email = applicationUser.Email, FullName = applicationUser.UserProfile.FullName, Id = applicationUser.UserProfile.Id, //ProfileImage = applicationUser.UserProfile.ProfileImage, ProfileImageString = Request.GetFileUrl((int)FileType.Profile, applicationUser.UserProfile.ProfileImageString) }); } return(null); }
public async Task <ActionResult> Login(Login login_) { if (ModelState.IsValid) { ApplicationUser user = await UserManager.FindAsync(login_.Email, login_.Password); if (user != null) { List <Claim> claims = new List <Claim>(); claims.Add(new Claim(ClaimTypes.NameIdentifier, login_.Email)); //, user.FirstName,user.LastName)); var identity = new ClaimsIdentity(claims, DefaultAuthenticationTypes.ApplicationCookie); AuthenticationManager.SignIn(identity); if (AuthenticationManager.AuthenticationResponseGrant.Identity.IsAuthenticated) { DbLevel NW = new DbLevel(); Employees empl = NW.GetEmployee(user); if (empl != null) { TempData["Message"] = @"Welcome" + empl.FirstName + "!"; return(RedirectToAction("Orders", "Edit", new { userID = user.Id })); } else { TempData["Message"] = @"Something werid happened. No employee."; return(View("Register", "Validation")); } } else { TempData["Message"] = @"User not signed in"; } } else { TempData["Message"] = @"Wrong password or username"; } } login_.Message = TempData["Message"] as string; return(View(login_)); }
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { // to validate user for login var userStore = new UserStore <ApplicationUser>(new ApplicationDbContext()); var manager = new UserManager <ApplicationUser>(userStore); var user = await manager.FindAsync(context.UserName, context.Password); if (user != null) { //if (user.EmailConfirmed) //{ var identity = new ClaimsIdentity(context.Options.AuthenticationType); identity.AddClaim(new Claim("Username", user.UserName)); identity.AddClaim(new Claim("Email", user.Email)); identity.AddClaim(new Claim("FirstName", user.FirstName)); identity.AddClaim(new Claim("LastName", user.LastName)); identity.AddClaim(new Claim("LoggedOn", DateTime.Now.ToString())); var userRoles = manager.GetRoles(user.Id); foreach (string roleName in userRoles) { identity.AddClaim(new Claim(ClaimTypes.Role, roleName)); } //return data to client var additionalData = new AuthenticationProperties(new Dictionary <string, string> { { "role", Newtonsoft.Json.JsonConvert.SerializeObject(userRoles) } }); var token = new AuthenticationTicket(identity, additionalData); context.Validated(token); // } //else //{ // context.SetError("invalid_grant", "Account pending approval"); // return; //} } else { context.SetError("invalid_grant", "The user name or password is incorrect"); return; } }
public async Task <ActionResult> LogIn(LogInViewModel model) { if (!ModelState.IsValid) { return(View()); } var user = await userManager.FindAsync(model.UserName, model.Password); if (user != null) { await SignIn(user); return(Redirect(GetRedirectUrl(model.ReturnUrl))); } ModelState.AddModelError("", "Неверный логин или пароль"); return(View()); }
protected virtual async Task <ShaLoginResult <TTenant, TUser> > LoginAsyncInternal(UserLoginInfo login, string tenancyName) { if (login == null || login.LoginProvider.IsNullOrEmpty() || login.ProviderKey.IsNullOrEmpty()) { throw new ArgumentException("login"); } //Get and check tenant TTenant tenant = null; if (!MultiTenancyConfig.IsEnabled) { tenant = await GetDefaultTenantAsync(); } else if (!string.IsNullOrWhiteSpace(tenancyName)) { tenant = await TenantRepository.FirstOrDefaultAsync(t => t.TenancyName == tenancyName); if (tenant == null) { return(new ShaLoginResult <TTenant, TUser>(ShaLoginResultType.InvalidTenancyName)); } if (!tenant.IsActive) { return(new ShaLoginResult <TTenant, TUser>(ShaLoginResultType.TenantIsNotActive, tenant)); } } int?tenantId = tenant == null ? (int?)null : tenant.Id; using (UnitOfWorkManager.Current.SetTenantId(tenantId)) { var user = await UserManager.FindAsync(tenantId, login); if (user == null) { return(new ShaLoginResult <TTenant, TUser>(ShaLoginResultType.UnknownExternalLogin, tenant)); } return(await CreateLoginResultAsync(user, tenant)); } }
[ValidateAntiForgeryToken]//表示用于阻止伪造请求的特性 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.RemeberMe); return(RedirectToLocal(returnUrl)); } else { ModelState.AddModelError("", "Invalid username or password."); } } return(View(model)); }
public async Task <ActionResult> LogIn([Bind(Include = "UserName,Password,RememberMe")] LogIn login) { if (ModelState.IsValid) { var user = await UserManager.FindAsync(login.UserName, login.Password); if (user != null) { await SignInAsync(user, login.RememberMe); } else { ModelState.AddModelError("", "Invalid username or password."); } //return RedirectToAction("Index", "Home"); } return(RedirectToAction("Index", "Home")); }
private async Task <ActionResult> RedirectToLocalAsync(string returnUrl, LoginViewModel model) { if (Url.IsLocalUrl(returnUrl)) { return(Redirect(returnUrl)); } ApplicationUser user = await UserManager.FindAsync(model.UserName, model.Password); //get imagepath from the user.. UnitOfWork _unitOfWork = new UnitOfWork(new ApplicationDbContext()); var fullUserData = _unitOfWork.UserRepositry.GetUserWithProjectsAndTasksAndRolesAndFilesAndFinanicalWithFilesWithPayments(user.Id); fullUserData.MyFiles = new List <MyUserFile>(); // Redirect to User landing page on SignIn, according to Role if ((UserManager.IsInRole(user.Id, "Admin"))) { //send image user to put it in loagin partial if (fullUserData.MyFiles.Count != 0) { if (fullUserData.MyFiles.LastOrDefault(f => f.MyFileType == MyFileType.Photo).FileName != null) { Session["imgPath"] = fullUserData.MyFiles.LastOrDefault(f => f.MyFileType == MyFileType.Photo).FileName; } } return(RedirectToAction("Index", "Admin")); } else { if (fullUserData.MyFiles.Count != 0) { if (fullUserData.MyFiles.LastOrDefault(f => f.MyFileType == MyFileType.Photo).FileName != null) { Session["imgPath"] = fullUserData.MyFiles.LastOrDefault(f => f.MyFileType == MyFileType.Photo).FileName; } } return(RedirectToAction("ShowTaskForEmployee", "TTask")); } }
protected override async Task <IPrincipal> AuthenticateAsync(string userName, string password, CancellationToken cancellationToken) { UserManager <ApplicationUser> userManager = CreateUserManager(); cancellationToken.ThrowIfCancellationRequested(); // Unfortunately, UserManager doesn't support CancellationTokens. ApplicationUser user = await userManager.FindAsync(userName, password); if (user == null) { // No user with userName/password exists. return(null); } // Create a ClaimsIdentity with all the claims for this user. cancellationToken.ThrowIfCancellationRequested(); // Unfortunately, IClaimsIdenityFactory doesn't support CancellationTokens. ClaimsIdentity identity = await userManager.ClaimsIdentityFactory.CreateAsync(userManager, user, "Basic"); return(new ClaimsPrincipal(identity)); }
public async Task <IHttpActionResult> DeleteAccount([FromBody] string Password) { var user = await UserManager.FindByIdAsync(User.Identity.GetUserId()); if (Password == null) { return(BadRequest("Provide Password.")); } var user1 = await UserManager.FindAsync(user.Email, Password); IdentityResult result = await UserManager.DeleteAsync(user1); if (!result.Succeeded) { return(GetErrorResult(result)); } return(Ok()); }
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl) { if (ModelState.IsValid) { var user = await UserManager.FindAsync(model.UserName, model.Password); if (model.UserName.IsValidEmail()) { var userByEmail = await UserManager.FindByEmailAsync(model.UserName); if (userByEmail == null) { ModelState.AddModelError("", "Invalid username or password."); return(View(model)); } model.UserName = userByEmail.UserName; user = await UserManager.FindAsync(userByEmail.UserName, model.Password); } if (user != null) { var result = await SignInManager.PasswordSignInAsync(model.UserName, 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)); } } ModelState.AddModelError("", "Invalid username or password."); } 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 : true); switch (result) { case SignInStatus.Success: //return RedirectToLocal(returnUrl); var user = await UserManager.FindAsync(model.Email, model.Password); if (user.Forcechangpassword == true) { if (string.IsNullOrEmpty(returnUrl)) { returnUrl = "/Messages"; } ViewBag.ReturnUrl = returnUrl; return(RedirectToAction("Manage", new { Message = ManageMessageId.FirstTimeLogin, ReturnUrl = returnUrl })); } 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)); } }
//set token public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { var allowedOrigin = context.OwinContext.Get <string>("as:clientAllowedOrigin"); //client is null get all if (allowedOrigin == null) { allowedOrigin = "*"; } //add hearder token context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { allowedOrigin }); //create new AppicationUser UserManager <ApplicationUser> userManager = context.OwinContext.GetUserManager <UserManager <ApplicationUser> >(); ApplicationUser user; try { //Find user and pass user = await userManager.FindAsync(context.UserName, context.Password); if (user != null) { //create memory contains variable ClaimsIdentity identity = await userManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ExternalBearer); context.Validated(identity); } else { //show message context.SetError("invalid_grant", "Tài khoản hoặc mật khẩu không đúng.'"); context.Rejected(); } } catch { // Could not retrieve the user due to error. context.SetError("server_error"); context.Rejected(); return; } }
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { return(View(model)); } var user = await UserManager.FindAsync(model.Email, model.Password); if (user == null) { ModelState.AddModelError("", "Invalid login attempt."); return(View(model)); } if (!user.EmailConfirmed) { ModelState.AddModelError("", "Email not verified. Please check your email inbox."); return(View(model)); } // This doen't count login failures towards lockout only two factor authentication // To enable password failures to trigger lockout, change to shouldLockout: true var result = await SignInHelper.PasswordSignIn(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 })); case SignInStatus.Failure: default: ModelState.AddModelError("", "Invalid login attempt."); return(View(model)); } }
public async Task <ResultWithData <string> > GetAuthTokenAsync(string email, string password) { var result = new ResultWithData <string>(); try { ApplicationUser appUser; var appUserByEmail = await UserManager.FindByEmailAsync(email); if (appUserByEmail != null) { appUser = await UserManager.FindAsync(appUserByEmail.UserName, password); } else { throw new Exception("Invalid login or password."); } if (appUser == null) { throw new Exception("Invalid login or password."); } var token = appUser.Token; if (String.IsNullOrEmpty(token)) { throw new Exception("Invalid auth token."); } result.ResultData = token; result.Success = true; } catch (Exception ex) { result.Success = false; result.Message = ex.Message; result.StackTrace = ex.StackTrace; } return(result); }
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { var userManager = new UserManager<User>(new UserStore<User>(new DatabaseContext())); var user = await userManager.FindAsync(context.UserName, context.Password); if (user == null) { context.SetError("invalid_grant", "The user name or password is incorrect."); return; } var oAuthIdentity = await userManager.CreateIdentityAsync(user, OAuthDefaults.AuthenticationType); var cookiesIdentity = await userManager.CreateIdentityAsync(user, CookieAuthenticationDefaults.AuthenticationType); var properties = CreateProperties(user.UserName); var ticket = new AuthenticationTicket(oAuthIdentity, properties); context.Validated(ticket); context.Request.Context.Authentication.SignIn(cookiesIdentity); }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { return View(model); } var userStore = new UserStore<ApplicationUser>(new DataContext()); var userManager = new UserManager<ApplicationUser>(userStore); var user = await userManager.FindAsync(model.Email, model.Password); if (user == null) { ModelState.AddModelError(string.Empty, "Пользователь с такой комбинацией пароля и логина не существует"); return View(model); } var authManager = HttpContext.GetOwinContext().Authentication; var userIdentity = await userManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); authManager.SignIn(new Microsoft.Owin.Security.AuthenticationProperties { IsPersistent = model.RememberMe }, userIdentity); return RedirectToLocal(returnUrl); }
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" }); AuthContext _ctx = new AuthContext(); using (UserManager<IdentityUser> _userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_ctx))) { IdentityUser user = await _userManager.FindAsync(context.UserName, context.Password); if (user == null) { context.SetError("invalid_grant", "The user name or password is incorrect."); return; } } var identity = new ClaimsIdentity(context.Options.AuthenticationType); identity.AddClaim(new Claim("sub", context.UserName)); identity.AddClaim(new Claim("role", "user")); identity.AddClaim(new Claim(ClaimTypes.Name, context.UserName)); context.Validated(identity); }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (ModelState.IsValid) { // カスタマイズのポイント: // UserManagerのインスタンス作成時、 // 型引数:カスタマイズしたユーザー情報 // コンストラクタの引数:カスタマイズしたユーザストアのインスタンス // をそれぞれ渡す var userManager = new UserManager<MyAppUser>(new MyAppUserStore()); // カスタマイズのポイント: // パスワードのハッシュ化アルゴリズムとして、IPasswordHasherを実装したカスタムクラスのインスタンスを設定 userManager.PasswordHasher = new MyPasswordHasher(); var user = await userManager.FindAsync(model.UserName, model.Password); if (user != null) { var authentication = this.HttpContext.GetOwinContext().Authentication; var identify = await userManager.CreateIdentityAsync( user, DefaultAuthenticationTypes.ApplicationCookie); authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie); authentication.SignIn(new AuthenticationProperties() { IsPersistent = false }, identify); return Redirect(returnUrl); } else { ModelState.AddModelError("", "ログインIDまたはパスワードが無効です。"); } } // ここで問題が発生した場合はフォームを再表示します return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (!ModelState.IsValid) { return View(model); } var userStore = new UserStore<IdentityUser>(); var userManager = new UserManager<IdentityUser>(userStore); var user = await userManager.FindAsync(model.Username, model.Password); if (user != null) { ModelState.AddModelError(string.Empty, "The user already exists."); return View(model); } user = new IdentityUser { UserName = model.Username, Email = model.Email }; await userManager.CreateAsync(user, model.Password); return RedirectToAction("index", "home"); }
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { using (var dbContext = new InstantDeliveryContext()) { var userManager = new UserManager<User>(new UserStore<User>(dbContext)); User user = await userManager.FindAsync(context.UserName, context.Password); if (user == null) { context.SetError("invalid_grant", "The user name or password is incorrect."); return; } ClaimsIdentity oAuthIdentity = await user.GenerateUserIdentityAsync(userManager, OAuthDefaults.AuthenticationType); ClaimsIdentity cookiesIdentity = await user.GenerateUserIdentityAsync(userManager, CookieAuthenticationDefaults.AuthenticationType); AuthenticationProperties properties = CreateProperties(user.UserName); AuthenticationTicket ticket = new AuthenticationTicket(oAuthIdentity, properties); context.Validated(ticket); context.Request.Context.Authentication.SignIn(cookiesIdentity); } }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { return View(model); } List<Tenant> tenants = new List<Tenant>(); tenants.Add(new Tenant() { Id = 1, Name = "K Force", DbContext = "KforceDB", Email = "*****@*****.**" }); tenants.Add(new Tenant() { Id = 2, Name = "Sudeep Company", DbContext = "SudeepDB", Email = "*****@*****.**" }); string dbContext = tenants.First(x => x.Id == model.TenantId).DbContext; ApplicationDbContext _db= new ApplicationDbContext(dbContext); UserManager<ApplicationUser> _myUserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(_db)); var user = await _myUserManager.FindAsync("tcadmin", model.Password); if (user != null) { var claim = await _myUserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = model.RememberMe }, claim); return RedirectToAction("Index", "Admin"); } //_myUserManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie); // 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); //} ViewData["Tenants"] = (from t in tenants select new SelectListItem() { Text = t.Name, Value = t.Id.ToString() }).ToList(); return View(model); }
public static async void ConfigureUsers(IEnumerable<InMemoryUser> users, EntityFrameworkServiceOptions options, UserManager userManager) { using(var db = new Contexto(options.ConnectionString)) { if(!db.Users.Any()) { foreach(var u in users) { var entity = new Usuario { Email = u.Claims.First(x=>x.Type==Constants.ClaimTypes.Email).Value , UserName = u.Username }; var response = await userManager.CreateAsync(entity, u.Password); if(!response.Succeeded) { throw new Exception("Não foi possível criar o usuario" + u.Username + response.Errors.ToString()); } else { var user = await userManager.FindAsync(u.Username,u.Password); foreach(var c in u.Claims) { await userManager.AddClaimAsync(user.Id,c); } await userManager.UpdateAsync(user); } } db.SaveChanges(); } } }
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { //try { var allowedOrigin = context.OwinContext.Get<string>("as:clientAllowedOrigin"); if (allowedOrigin == null) allowedOrigin = "*"; context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { allowedOrigin }); var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext())); ApplicationUser user = await userManager.FindAsync(context.UserName, context.Password); var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(new ApplicationDbContext())); if (user == null) { context.SetError("invalid_grant", "The user name or password is incorrect."); return; } if (!user.EmailConfirmed) { context.SetError("invalid_grant", "User did not confirm email."); return; } var identity = new ClaimsIdentity(context.Options.AuthenticationType); identity.AddClaim(new Claim(ClaimTypes.Name, context.UserName)); user.Roles.ToList().ForEach(r => { var role = roleManager.FindById(r.RoleId); identity.AddClaim(new Claim(ClaimTypes.Role, role.Name)); }); identity.AddClaim(new Claim("sub", context.UserName)); var props = new AuthenticationProperties(new Dictionary<string, string> { { "as:client_id", (context.ClientId == null) ? string.Empty : context.ClientId }, { "userName", context.UserName } }); var ticket = new AuthenticationTicket(identity, props); context.Validated(ticket); //} //catch (Exception ex) //{ // throw; // } }
public async Task<JsonData> Login(LoginModel model) { try { using (var db = new DataContext()) { var userMan = new UserManager<MyUser>(new UserStore<MyUser>(db)); //get the user by the email address var us = new UserRepo().GetUserByName(model.UserName, db); if (us == null) throw new Exception("Please check the login details"); var user = await userMan.FindAsync(us.UserName, model.Password); if (user == null) throw new Exception("Please check the login details"); if (!user.IsActive) throw new Exception("You can not login because your user is not active"); var authenticationManager = HttpContext.Current.GetOwinContext().Authentication; authenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie); var identity = await userMan.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); authenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = model.RememberMe }, identity); var ticket = new AuthenticationTicket(identity, new AuthenticationProperties()); var token = Startup.OAuthOptions.AccessTokenFormat.Protect(ticket); return DataHelpers.ReturnJsonData(user, true, token); } } catch (Exception e) { return DataHelpers.ExceptionProcessor(e); } }
public async Task SetupAsync() { _userViewModel = new LoginViewModel { Email = "*****@*****.**", Password = "******", RememberMe = false }; var context = new DataContext(); _manager = new UserManager(new UserStore(context)); _controller = new AccountController(_manager); var user = await _manager.FindAsync(_userViewModel.Email, _userViewModel.Password); if (user == null) { await _manager.CreateAsync(new User { Email = _userViewModel.Email, UserName = _userViewModel.Email }, _userViewModel.Password); } var mockCp = new Mock<IClaimsPrincipal>(); if (user != null) mockCp.SetupGet(cp => cp.UserId).Returns(user.Id); _controller.CurrentUser = mockCp.Object; var mockAuthenticationManager = new Mock<IAuthenticationManager>(); mockAuthenticationManager.Setup(am => am.SignOut()); mockAuthenticationManager.Setup(am => am.SignIn()); _controller.AuthenticationManager = mockAuthenticationManager.Object; }