public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
using (AppUserManager userManager = _userManagerFactory())
{
ApplicationUser 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 userManager.CreateIdentityAsync(user,
context.Options.AuthenticationType);
ClaimsIdentity cookiesIdentity = await userManager.CreateIdentityAsync(user,
CookieAuthenticationDefaults.AuthenticationType);
// ADDED FROM INTERNET!!!!/
oAuthIdentity.AddClaim(new Claim(ClaimTypes.Sid, user.Id.ToString()));
cookiesIdentity.AddClaim(new Claim(ClaimTypes.Sid, user.Id.ToString()));
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(LogInModel model)
{
if (!ModelState.IsValid) //Checks if input fields have the correct format
{
return(View()); //Returns the view with the input values.
}
User user = await userManager.FindAsync(model.UserName, model.Password);
if (user != null && user.LockoutEnabled == false)
{
ClaimsIdentity identity = await userManager.CreateIdentityAsync(
user, DefaultAuthenticationTypes.ApplicationCookie);
identity.AddClaim(new Claim(ClaimTypes.Sid, user.Id.ToString()));
var authManager = Request.GetOwinContext().Authentication;
authManager.SignIn(identity);
return(Redirect(GetRedirectUrl(model.ReturnUrl)));
}
ModelState.AddModelError("", "Invalid email or password");
return(View());
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
User user = new User
{
UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
ClaimsIdentity claim = await UserManager.CreateIdentityAsync(user,
DefaultAuthenticationTypes.ApplicationCookie);
claim.AddClaim(new Claim("FirstName", user.FirstName));
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(new AuthenticationProperties
{
IsPersistent = true
}, claim);
return(RedirectToAction("Main", "Main"));
}
else
{
foreach (string error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
}
return(View(model));
}
public async Task <ActionResult> Login(LoginViewModel model)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindAsync(model.Email, model.Password);
if (user == null)
{
ModelState.AddModelError("", "无效的用户名和密码");
}
else
{
var claimsIdentity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
//claimsIdentity.AddClaims(LocationClaimsProvider.GetClaims(claimsIdentity));
//claimsIdentity.AddClaims(ClaimsRoles.CreateRolesFromClaims(claimsIdentity));
AuthManager.SignOut();
AuthManager.SignIn(new AuthenticationProperties {
IsPersistent = false
}, claimsIdentity);
return(RedirectToAction("Index", "Home"));
}
}
return(View(model));
}
public async Task <ClaimsIdentity> GenerateUserIdentityAsync(AppUserManager userManager)
{
var userIdentity = await userManager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
// Add custom user claims here
return(userIdentity);
}
public async Task <ActionResult> Register(RegisterModel model)
{
if (ModelState.IsValid)
{
User user = new User {
UserName = model.Email, Email = model.Email, RegisterDate = DateTime.Now, LastOnline = DateTime.Now, Name = model.Name
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
ClaimsIdentity claim = await UserManager.CreateIdentityAsync(user,
DefaultAuthenticationTypes.ApplicationCookie);
UserManager.AddToRole(user.Id, "user");
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(new AuthenticationProperties
{
IsPersistent = true
}, claim);
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (string error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
}
return(View(model));
}
public async Task <ActionResult> Login(Login login)
{
var secret = "6LfBQOIUAAAAAODnw5bhLcW7QO3nvL9EuZ5S27qC";
var g_captcha = this.Request.Form["g-recaptcha-response"];
var response = new WebClient().DownloadString(string.Format("https://www.google.com/recaptcha/api/siteverify?secret={0}&response={1}", secret, g_captcha));
var recaptchaResponse = JsonConvert.DeserializeObject <RecaptchaResponse>(response);
if (recaptchaResponse.Success)
{
var user = await _userManager.FindAsync(login.UserName, login.Password);
if (user != null)
{
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
var identity = await _userManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationManager.SignIn(new AuthenticationProperties()
{
IsPersistent = true
}, identity);
return(RedirectToAction("Create", new { cliente = login.UserName }));
}
}
ViewBag.Error = "Usuario o contraseña incorrectos.";
return(View(login));
}
public async Task <ActionResult> Login(AdminLoginModel model, string ReturnUrl)
{
if (ModelState.IsValid)
{
AppUser user = await userManager.FindAsync(model.ID, model.Password);
if (user == null)
{
//ModelState.AddModelError("Password", "아이디 또는 비밀번호가 잘못되었습니다.");
TempData["message"] = "아이디 또는 비밀번호가 잘못되었습니다.";
}
else
{
authManager = System.Web.HttpContext.Current.GetOwinContext().Authentication;
ClaimsIdentity ident = await userManager.CreateIdentityAsync(user,
DefaultAuthenticationTypes.ApplicationCookie);
authManager.SignOut();
authManager.SignIn(new AuthenticationProperties {
IsPersistent = true
}, ident);
ViewBag.AdminId = model.ID;
return(RedirectToAction("Index"));
}
}
ViewBag.returnUrl = ReturnUrl;
return(View(model));
}
public async Task <ActionResult> Login(UserLoginViewModel model)
{
if (ModelState.IsValid)
{
AppUser user = await _userManager.FindAsync(model.Email, model.Password);
if (user == null)
{
ModelState.AddModelError("", "Invalid name or password");
}
else
{
if (!await _userManager.IsEmailConfirmedAsync(user.Id))
{
string code = await _userManager.GenerateEmailConfirmationTokenAsync(user.Id);
string callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
_mailingRepository.ActivationMail(user.Email, callbackUrl);
Response.StatusCode = (int)HttpStatusCode.Forbidden;
return(PartialView("_Error", new string[] { "You must have a confirmed email to log on. Check your email for activation link." }));
}
ClaimsIdentity ident = await _userManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
_authManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
_authManager.SignIn(new AuthenticationProperties
{
IsPersistent = false,
}, ident);
return(Json(new { url = "/" }));
}
}
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(PartialView(model));
}
private void CreateIdentity(string sessionJson)
{
var session = _apiProvider.DeserializeJson <Session>(sessionJson);
var appUser = new AppUser(session.UserId.ToString(), "User");
var task = _appUserManager.CreateIdentityAsync(appUser, DefaultAuthenticationTypes.ApplicationCookie);
task.Wait();
var claim = task.Result;
var authMgr = HttpContext.GetOwinContext().Authentication;
var authProperties = new AuthenticationProperties()
{
IsPersistent = false
};
authProperties.Dictionary["Session"] = sessionJson;
foreach (var role in session.Roles)
{
var appRole = _appRoleManager.FindById(role.RoleID.ToString());
if (appRole != null)
{
_appUserManager.AddToRoleAsync(appUser.Id.ToString(), appRole.Name);
}
}
authMgr.SignIn(authProperties, claim);
}
public async Task <ClaimsIdentity> GenerateUserIdentityAsync(AppUserManager manager, string authenticationType)
{
var userIdentity = await manager.CreateIdentityAsync(this, authenticationType);
// Add custom user claims here
return(userIdentity);
}
public async Task <ClaimsIdentity> GenerateUserIdentityAsync(AppUserManager manager, string authenticationType)
{
// Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
var userIdentity = await manager.CreateIdentityAsync(this, authenticationType);
// Add custom user claims here
return(userIdentity);
}
public async Task <ClaimsIdentity> Authenticate(UserDTO userDto)
{
AppUser user = await _userMng.FindAsync(userDto.Email, userDto.Password);
ClaimsIdentity claim = user != null ? await _userMng.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie) : null;
_userMng.Dispose();
return(claim);
}
/// <summary>
/// Sign out as current identity and sign in as newly-created identity
/// </summary>
private async Task SignInAsync(Backer user, bool isPersistent)
{
Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
var identity = await AppUserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
Authentication.SignIn(new AuthenticationProperties()
{
IsPersistent = isPersistent
}, identity);
}
public async Task <ClaimsIdentity> Login(LoginViewModel model)
{
var user = await userManager.FindAsync(model.Username, model.Password);
if (user == null)
{
throw new ApplicationException("Invalid name or password.");
}
return(await userManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie));
}
public async Task <ClaimsIdentity> GenerateUserIdentityAsync(AppUserManager manager)
{
// Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
// Store the company id in a claim.
// manager.AddClaim(Id, new Claim("CompanyId", CompanyId.ToString()));
// Add custom user claims here
return(userIdentity);
}
private async Task SignInAsync(User user, bool isPersistent)
{
var claimsIdentity =
await _userManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(new AuthenticationProperties {
IsPersistent = isPersistent
},
claimsIdentity);
}
public async Task <ClaimsIdentity> Authenticate(UserDTO userDto)
{
AppUserManager appUserManager = (AppUserManager)Database.UserManager;
ClaimsIdentity claim = null;
// find user
ApplicationUser user = await appUserManager.FindAsync(userDto.Email, userDto.Password);
// authorize user и return object ClaimsIdentity
if (user != null)
{
claim = await appUserManager.CreateIdentityAsync(user,
DefaultAuthenticationTypes.ApplicationCookie);
}
return(claim);
}
public async Task <ClaimsIdentity> GenerateUserIdentityAsync(AppUserManager appUserManager, bool isPersistentState, bool screenLockedState)
{
var identity = await appUserManager.CreateIdentityAsync(
this,
DefaultAuthenticationTypes.ApplicationCookie
);
var claims = AppPrincipal.GetAdminClaims(
appUserEntity: this,
isPersistent: isPersistentState,
screenLocked: screenLockedState
);
foreach (var claim in claims)
{
if (!identity.HasClaim(claim.Type, claim.Value))
{
identity.AddClaim(claim);
}
}
return(identity);
}
public async Task <ClaimsIdentity> GenerateUserIdentityAsync(AppUserManager <ApplicationUser> manager)
{
var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
return(userIdentity);
}
public async Task <ClaimsIdentity> CreateIdentityAsync(ApplicationUser user, string authenticationType)
{
return(await _userManager.CreateIdentityAsync(user, authenticationType));
}
