public ProcessUserAuthorization ( System.Web.HttpRequestBase request = null ) : IAuthorizationState | ||
request | System.Web.HttpRequestBase | The incoming HTTP request that may carry an authorization response. |
return | IAuthorizationState |
public virtual IAuthorizationState ProcessUserAuthorization( WebServerClient authClient, AuthorizationServerDescription authServer, IServiceBase authService) { return HostContext.Config.StripApplicationVirtualPath ? authClient.ProcessUserAuthorization(authService.Request.ToHttpRequestBase()) : authClient.ProcessUserAuthorization(); }
// GET: Account public ActionResult Login(string returnUrl) { _webServerClient = OAuthConfiguration.InitializeWebServerClient(); var result = _webServerClient.ProcessUserAuthorization(Request); if (result == null) { var userAuthorization = _webServerClient.PrepareRequestUserAuthorization(); //Clear returnUrl userAuthorization.Send(HttpContext); Response.End(); } else { var username = OAuthConfiguration.GetMe(result.AccessToken); var user = UserManager.FindByName(username); if (user != null) { SignInManager.SignIn(user, false, false); } else { var newuser = new ApplicationUser { UserName = username, Email = username }; UserManager.Create(newuser); SignInManager.SignIn(newuser, false, false); } return RedirectToLocal(returnUrl); } return View(); }
public ActionResult AuthorizationCodeGrant(string code, string state) { ViewBag.Message = "Modify this template to jump-start your ASP.NET MVC application."; var model = new AuthorizationCodeGrantViewModel { ClientId = "demo-client-auth-code-identifier", ClientSecret = "demo-client-auth-code-secret-key", Scope = "user" }; if (!string.IsNullOrWhiteSpace(code) && !string.IsNullOrWhiteSpace(state)) { var client = new WebServerClient(_authServerDescription, model.ClientId, model.ClientSecret); this.ViewBag.AccessToken = client.ProcessUserAuthorization(this.Request); } this.ViewBag.AuthorizationCode = code; this.ViewBag.AuthorizationState = state; return this.View(model); }
protected void Page_Load(object sender, EventArgs e) { var authorizationServer = new AuthorizationServerDescription { AuthorizationEndpoint = new Uri("http://localhost:18001/Katana.Sandbox.WebServer/Authorize"), TokenEndpoint = new Uri("http://localhost:18001/Katana.Sandbox.WebServer/Token") }; _webServerClient = new WebServerClient(authorizationServer, "123456", "abcdef"); if (string.IsNullOrEmpty(AccessToken.Text)) { var authorizationState = _webServerClient.ProcessUserAuthorization(new HttpRequestWrapper(Request)); if (authorizationState != null) { AccessToken.Text = authorizationState.AccessToken; Page.Form.Action = Request.Path; } } }
// for getting initial access and renewal tokens via OAuth handshake IAuthorizationState GetGoogleTokens(WebServerClient client) { // check if authorization request already is in progress IAuthorizationState state = client.ProcessUserAuthorization(new HttpRequestInfo(System.Web.HttpContext.Current.Request)); if (state != null && (!string.IsNullOrEmpty(state.AccessToken) || !string.IsNullOrEmpty(state.RefreshToken))) { // store refresh token string username = System.Web.HttpContext.Current.User.Identity.Name; UserStorageContext storage = Storage.NewUserContext; User user = storage.Users.Include("UserCredentials").Single<User>(u => u.Name == username); user.AddCredential(UserCredential.GoogleConsent, state.AccessToken, state.AccessTokenExpirationUtc, state.RefreshToken); storage.SaveChanges(); return state; } // otherwise make a new authorization request OutgoingWebResponse response = client.PrepareRequestUserAuthorization(GoogleClient.Scopes); response.Headers["Location"] += "&access_type=offline&approval_prompt=force"; response.Send(); // will throw a ThreadAbortException to prevent sending another response return null; }
/// <summary>The entry point for all AuthProvider providers. Runs inside the AuthService so exceptions are treated normally. Overridable so you can provide your own Auth implementation.</summary> /// /// <param name="authService">The authentication service.</param> /// <param name="session"> The session.</param> /// <param name="request"> The request.</param> /// /// <returns>An object.</returns> public override object Authenticate(IServiceBase authService, IAuthSession session, Auth request) { var tokens = this.Init(authService, ref session, request); var authServer = new AuthorizationServerDescription { AuthorizationEndpoint = new Uri(this.AuthorizeUrl), TokenEndpoint = new Uri(this.AccessTokenUrl) }; var authClient = new WebServerClient(authServer, this.ConsumerKey) { ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(this.ConsumerSecret), }; var authState = authClient.ProcessUserAuthorization(); if (authState == null) { try { var authReq = authClient.PrepareRequestUserAuthorization(this.Scopes, new Uri(this.CallbackUrl)); var authContentType = authReq.Headers[HttpHeaders.ContentType]; var httpResult = new HttpResult(authReq.ResponseStream, authContentType) { StatusCode = authReq.Status, StatusDescription = "Moved Temporarily" }; foreach (string header in authReq.Headers) { httpResult.Headers[header] = authReq.Headers[header]; } foreach (string name in authReq.Cookies) { var cookie = authReq.Cookies[name]; if (cookie != null) { httpResult.SetSessionCookie(name, cookie.Value, cookie.Path); } } authService.SaveSession(session, this.SessionExpiry); return httpResult; } catch (ProtocolException ex) { Log.Error("Failed to login to {0}".Fmt(this.Provider), ex); return authService.Redirect(session.ReferrerUrl.AddHashParam("f", "Unknown")); } } var accessToken = authState.AccessToken; if (accessToken != null) { try { tokens.AccessToken = accessToken; tokens.RefreshToken = authState.RefreshToken; tokens.RefreshTokenExpiry = authState.AccessTokenExpirationUtc; session.IsAuthenticated = true; var authInfo = this.CreateAuthInfo(accessToken); this.OnAuthenticated(authService, session, tokens, authInfo); return authService.Redirect(session.ReferrerUrl.AddHashParam("s", "1")); } catch (WebException we) { var statusCode = ((HttpWebResponse)we.Response).StatusCode; if (statusCode == HttpStatusCode.BadRequest) { return authService.Redirect(session.ReferrerUrl.AddHashParam("f", "AccessTokenFailed")); } } } return authService.Redirect(session.ReferrerUrl.AddHashParam("f", "RequestTokenFailed")); }
// GetAuthorization /// <summary> /// Gets the authorization object for the client-side flow /// </summary> /// <param name="client">The web server client used for authorization</param> /// <returns>An authorization state that can be used for API queries </returns> private IAuthorizationState GetAuthorization(WebServerClient client) { if (_authstate == null) { if (_refreshToken != null) { _authstate = CreateState(_refreshToken, false); } if (_accessToken != null) { _authstate = CreateState(_accessToken, true); } } // If this user is already authenticated, then just return the auth state. IAuthorizationState state = _authstate; if (state != null) { return state; } // Check if an authorization request already is in progress. HttpRequestInfo reqinfo = new HttpRequestInfo(HttpContext.Current.Request); //if (reqinfo) state = client.ProcessUserAuthorization(reqinfo); // Check to see if we have an access token and use that to generate the state. if (_accessToken != null) { state = CreateState(_accessToken, true); // Check to see if we have a refresh token and use that to get the auth state. } else if (_refreshToken != null) { state = CreateState(_refreshToken); bool worked = client.RefreshToken(state); if (state != null) { return state; } } if (state != null && (!string.IsNullOrEmpty(state.AccessToken) || !string.IsNullOrEmpty(state.RefreshToken))) { // Store and return the credentials. HttpContext.Current.Session["AUTH_STATE"] = _authstate = state; _accessToken = state.AccessToken; _refreshToken = state.RefreshToken; return state; } // Otherwise do a new authorization request. string scope = "https://www.googleapis.com/auth/plus.login"; OutgoingWebResponse response = client.PrepareRequestUserAuthorization(new[] { scope }); response.Send(); // Will throw a ThreadAbortException to prevent sending another response. return null; }
/// <summary> /// Gets the authorization object for the client-side flow. /// </summary> /// <param name="client">The client used for authorization. /// </param> /// <returns>An authorization state that can be used for API queries. /// </returns> protected IAuthorizationState GetAuthorization(WebServerClient client) { // If we don't yet have user, use the client to perform // authorization. if (_authState != null) { HttpRequestInfo reqinfo = new HttpRequestInfo(HttpContext.Current.Request); client.ProcessUserAuthorization(reqinfo); } // Check for a cached session state. if (_authState == null) { _authState = (IAuthorizationState)HttpContext.Current. Session["AUTH_STATE"]; } // Check if we need to refresh the authorization state and refresh // it if necessary. if (_authState != null) { if (_authState.RefreshToken.IsNotNullOrEmpty() && (_authState.AccessToken == null || DateTime.UtcNow > _authState.AccessTokenExpirationUtc)) { client.RefreshToken(_authState); } return _authState; } // If we fall through to here, perform an authorization request. OutgoingWebResponse response = client.PrepareRequestUserAuthorization(); response.Send(); // Note: response.send will throw a ThreadAbortException to // prevent sending another response. return null; }
private IAuthorizationState GetAuthorization(WebServerClient client) { // If this user is already authenticated, then just return the auth state. IAuthorizationState state = AuthState; if (state != null) { return state; } // Check if an authorization request already is in progress. state = client.ProcessUserAuthorization(new HttpRequestInfo(HttpContext.Current.Request)); if (state != null && (!string.IsNullOrEmpty(state.AccessToken) || !string.IsNullOrEmpty(state.RefreshToken))) { // Store and return the credentials. HttpContext.Current.Session["AUTH_STATE"] = _state = state; return state; } // Otherwise do a new authorization request. string scope = "https://www.googleapis.com/auth/plus.me"; OutgoingWebResponse response = client.PrepareRequestUserAuthorization(new[] { scope }); response.Send(); // Will throw a ThreadAbortException to prevent sending another response. return null; }
private IAuthorizationState GetAuthorization(WebServerClient client) { // If this user is already authenticated, then just return the auth state. IAuthorizationState state = _state ?? _userRepository.GetCalendarAuthorization(SettingsRepository.Reddit.BotLogin); if (state != null) return state; // Check if an authorization request already is in progress. System.Threading.Thread.Sleep(2000); state = client.ProcessUserAuthorization(); if (state != null && (!string.IsNullOrEmpty(state.AccessToken) || !string.IsNullOrEmpty(state.RefreshToken))) { // Store and return the credentials. _userRepository.UpdateCalendarAuthorization(SettingsRepository.Reddit.BotLogin, _state = state); return state; } // Otherwise do a new authorization request. return null; }
private IAuthorizationState GetAuthorization(WebServerClient myWebServerClient) { var state = HttpContext.Current.Session["GA_AUTH_STATE"] as IAuthorizationState; if (state != null) { return state; } state = myWebServerClient.ProcessUserAuthorization( new HttpRequestInfo(HttpContext.Current.Request) ); if (state != null && (state.AccessToken.IsNotEmpty() || state.RefreshToken.IsNotEmpty())) { HttpContext.Current.Session["GA_AUTH_STATE"] = state; return state; } var scopes = new[] { "https://www.google.com/analytics/feeds/", "https://www.googleapis.com/auth/analytics.readonly" }; myWebServerClient.PrepareRequestUserAuthorization(scopes).Send(); return null; }