public IAuthorizationState RequestAccessToken(string refreshToken) { { WebServerClient consumer = new WebServerClient(ServerDescription, ClientID, ClientSecret) { AuthorizationTracker = new AuthorizationTracker(Scope) }; IAuthorizationState grantedAccess = PrepareAuthorizationState(refreshToken); if (grantedAccess != null) { try { consumer.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(ClientSecret); consumer.RefreshAuthorization(grantedAccess, null); return(grantedAccess); } catch (Exception ex) { _log.Error("RefreshAuthorization() Exception:\r\n{0}\r\n", ex.ToString()); } } return(null); } }
protected void btnGetToken_Click(object sender, EventArgs e) { if (!Page.IsValid) { return; } try { ToSession(); WebServerClient consumer = new WebServerClient(Description(), CurrentPageState.ClientID, CurrentPageState.ClientSecret); consumer.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(CurrentPageState.ClientSecret); IAuthorizationState grantedAccess = consumer.ProcessUserAuthorization(new HttpRequestWrapper(Request)); if (grantedAccess == null) { throw new MyFlightbook.MyFlightbookValidationException("Null access token returned - invalid authorization passed?"); } lblToken.Text = grantedAccess.AccessToken; } catch (MyFlightbook.MyFlightbookValidationException ex) { lblErr.Text = ex.Message; } catch (DotNetOpenAuth.Messaging.ProtocolException ex) { lblErr.Text = ex.Message; } }
//Authentication Method public void Authenticate() { var serverDescription = new AuthorizationServerDescription(); serverDescription.AuthorizationEndpoint = new Uri(AuthorizationEndpointUrl); serverDescription.TokenEndpoint = new Uri(TokenEndpointUrl); serverDescription.ProtocolVersion = ProtocolVersion.V20; var client = new WebServerClient(serverDescription); client.ClientIdentifier = ClientIdentifier; client.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(ClientSecret); var token = client.GetClientAccessToken(); //var request = (HttpWebRequest)WebRequest.Create("http://localhost:8080/test/"); ////System.Diagnostics.Process.Start("http://localhost:8080/test/"); //request.Method = "GET"; //client.AuthorizeRequest(request, token); //var response = request.GetResponse(); //var postreqreader = new StreamReader(response.GetResponseStream()); //var json = postreqreader.ReadToEnd(); }
public ExactOnlineConnection(string clientId, string clientSecret, string redirectUri, string endPoint, IDropboxUserToken dropboxUserToken) { this.dropboxUserToken = dropboxUserToken; miscellaneousDocumentType = 55; generalCategory = Guid.Parse("3b6d3833-b31b-423d-bc3c-39c62b8f2b12"); //Guid.Parse(clientId); this.endPoint = endPoint; authorization = new AuthorizationState { Callback = new Uri(redirectUri) }; var token = dropboxUserToken.TryRetrieveTokenFromDatabase(HardcodedUser.Id); authorization.AccessToken = token.ExactAccessToken; authorization.AccessTokenExpirationUtc = token.ExactAccessTokenExpiration; exactClient = IsAccessTokenValid() ? new ExactOnlineClient(endPoint, GetAccessToken) : exactClient; var serverDescription = new AuthorizationServerDescription { AuthorizationEndpoint = new Uri(string.Format("{0}/api/oauth2/auth", endPoint)), TokenEndpoint = new Uri(string.Format("{0}/api/oauth2/token", endPoint)) }; oAuthClient = new UserAgentClient(serverDescription, clientId, clientSecret); oAuthClient.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(clientSecret); }
public FacebookClient() : base(Description, clientIdentifier: ConfigurationManager.AppSettings["FacebookClientID"], credentialApplicator: ClientCredentialApplicator.PostParameter(ConfigurationManager.AppSettings["FacebookSecretKey"]), requestScopes: new string[] { "email" }, // We'd like the "email" scope from Facebook in addition to what Facebook defines as "basic" dataRequestUri: "https://graph.facebook.com/me", identityProvider: Models.IdentityProvider.Facebook) { }
/// <summary> /// We enforce the provding of a <see cref="ClientCredentialApplicator"/> such that the consumer is forced to choose the method using which /// the client secret is sent to the authorization server. /// </summary> /// <param name="requestScopes">Set of scopes to inquire from the authorization server.</param> /// <param name="dataRequestUri">Location at which to inquire the data once the request is authenticated.</param> public AuthenticationClient(AuthorizationServerDescription description, string clientIdentifier, ClientCredentialApplicator credentialApplicator, string[] requestScopes, string dataRequestUri, IdentityProvider identityProvider) : base(description, clientIdentifier, credentialApplicator) { _requestScopes = requestScopes; _requestUri = dataRequestUri; _identityProvider = identityProvider; }
/// <summary> /// Convert an authorization token for an access token. /// </summary> /// <param name="Request">The http request</param> /// <returns>The granted access token</returns> public virtual IAuthorizationState ConvertToken(HttpRequest Request) { WebServerClient consumer = new WebServerClient(Description(), AppKey, AppSecret) { ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(AppSecret) }; return(consumer.ProcessUserAuthorization(new HttpRequestWrapper(Request))); }
/// <summary> /// Convert an authorization token for an access token. /// </summary> /// <param name="Request">The http request</param> /// <returns>The granted access token</returns> public virtual AuthorizationState ConvertToken(HttpRequest Request) { WebServerClient consumer = new WebServerClient(Description(), AppKey, AppSecret); consumer.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(AppSecret); IAuthorizationState grantedAccess = consumer.ProcessUserAuthorization(new HttpRequestWrapper(Request)); // Kindof a hack below, but we convert from IAuthorizationState to AuthorizationState via JSON so that we have a concrete object that we can instantiate. return(JsonConvert.DeserializeObject <AuthorizationState>(JsonConvert.SerializeObject(grantedAccess))); }
private UserAgentClient GetClient(Uri url) { var authServer = new AuthorizationServerDescription { AuthorizationEndpoint = null, // We are not actually using authorization, just authentication. TokenEndpoint = url }; return(new UserAgentClient(authServer, ClientIdentifier, ClientCredentialApplicator.PostParameter(ClientSecret))); }
public GoogleClient() : base(Description, clientIdentifier: ConfigurationManager.AppSettings["GoogleClientID"], // Guys at Google somehow require this to be in POST form. Documenting it in their docs would have been nice. credentialApplicator: ClientCredentialApplicator.PostParameter(ConfigurationManager.AppSettings["GoogleSecretKey"]), requestScopes: new string[] { "https://www.googleapis.com/auth/userinfo.profile", "https://www.googleapis.com/auth/userinfo.email" }, dataRequestUri: "https://www.googleapis.com/oauth2/v2/userinfo", identityProvider: IdentityProvider.Google) { }
public OAuthProvider(string guid, string name, string imageUrl, string tokenEndpoint, string authorizationEndpoint, string clientIdentifier, ClientCredentialApplicator credentialApplicator, bool requireUsername = false) : base(guid, name, imageUrl, requireUsername) { Description = new AuthorizationServerDescription { TokenEndpoint = new Uri(tokenEndpoint), AuthorizationEndpoint = new Uri(authorizationEndpoint) }; ClientIdentifier = clientIdentifier; CredentialApplicator = credentialApplicator; }
private WebServerClient GetClient(IOAuth2SignInSettings signInSettings) { AuthorizationServerDescription authorizationServerDescription = _endpointBuilder.Build(signInSettings); var client = new WebServerClient(authorizationServerDescription) { ClientIdentifier = signInSettings.ClientId, ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(signInSettings.ClientSecret) }; return(client); }
/// <summary> /// Create an HTTP Handler that supports OAuth user authentication. /// </summary> /// <param name="authBaseUri">The base auth URI e.g. https://auth.alitudeangel.com</param> /// <param name="clientId">Your client ID</param> /// <param name="clientSecret">Your client secret</param> /// <param name="scopes">Requested scopes</param> /// <param name="existingState">(optional) An existing state object from a previous session. May be null.</param> /// <param name="requireUserToken">true to aquire a user token, false to get a client only token.</param> /// <param name="redirectUri">The redirect URI to use for user token auth. Must match the registered URI for your client ID.</param> /// <param name="codeProvider">Implementation to use to get an authorization code URI from an auth login URI.</param> /// <returns> /// A <see cref="ClientHandlerInfo"/> object that contains the auth state and the handler. The auth state may be persisted and passed /// back in on future runs of the application to save login state. /// </returns> public static ClientHandlerInfo Create( string authBaseUri, string clientId, string clientSecret, IEnumerable <string> scopes, IAuthorizationState existingState, bool requireUserToken, string redirectUri, IAuthorizeCodeProvider codeProvider) { var serverDescription = GetServerDescription(authBaseUri); ClientBase client; var state = existingState; if (requireUserToken) { if (codeProvider == null || string.IsNullOrEmpty(redirectUri)) { throw new ArgumentNullException(nameof(codeProvider), $"{nameof(codeProvider)} or {nameof(redirectUri)} cannot be null if {nameof(requireUserToken)} is true."); } var userClient = new UserAgentClient(serverDescription, clientId, ClientCredentialApplicator.PostParameter(clientSecret)); if (state == null) { // Open browser here var returnTo = new Uri(redirectUri); var uri = userClient.RequestUserAuthorization(scopes, returnTo: returnTo); var result = codeProvider.GetCodeUri(uri, returnTo).Result; state = new AuthorizationState { Callback = returnTo }; state.Scope.AddRange(scopes); state = userClient.ProcessUserAuthorization(result, state); } client = userClient; } else { client = new WebServerClient(serverDescription, clientId, ClientCredentialApplicator.PostParameter(clientSecret)); state = state ?? client.GetClientAccessToken(scopes); } return(new ClientHandlerInfo( new BearerTokenHttpMessageHandler( client, state, new HttpClientHandler { AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate }), state)); }
/// <summary> /// Convert an authoriztion token for an access token. /// </summary> /// <param name="Request">The http request</param> /// <returns>The granted access token</returns> public static IAuthorizationState ConvertToken(HttpRequest Request) { WebServerClient consumer = new WebServerClient(Description(), MFBFacebook.FACEBOOK_API_KEY, MFBFacebook.FACEBOOK_SECRET); consumer.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(MFBFacebook.FACEBOOK_SECRET); IAuthorizationState grantedAccess = consumer.ProcessUserAuthorization(new HttpRequestWrapper(Request)); // Exchange for a longer lived token ExchangeToken(grantedAccess); return(grantedAccess); }
public ActionResult oauth2callback() { WebServerClient consumer = new WebServerClient(server, clientID, clientSecret); consumer.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(clientSecret); IAuthorizationState grantedAccess = consumer.ProcessUserAuthorization(null); string accessToken = grantedAccess.AccessToken; return(Content(accessToken)); }
private IAuthorizationState Authenticate(NativeApplicationClient client) { IAuthorizationState state = new AuthorizationState(new string[] { }) { RefreshToken = this.refreshToken }; // IMPORTANT - does not work without: client.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(this.clientSecret); client.RefreshAuthorization(state); return(state); }
public static WebServerClient CreateClient() { //pleasea contact hellopaisa for the credentials var desc = GetAuthServerDescription(); //client ID provided var client = new WebServerClient(desc, clientIdentifier: "ID"); //client secret/password provided client.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter("SECRET"); return(client); }
public OAuthMethod(string title, string logoClass, LoginService srv, string authEndpoint, string tokenEndpoint, string clientId, string clientSecret, string emailScope, string requestUrl, Func <JToken, string> uniqueIDFromPerson) { _client = new WebServerClient(new AuthorizationServerDescription { AuthorizationEndpoint = new Uri(authEndpoint), TokenEndpoint = new Uri(tokenEndpoint) }, clientId, ClientCredentialApplicator.PostParameter(clientSecret)); Id = title; _srv = srv; _requestUrl = requestUrl; _emailScope = emailScope; _uniqueIDFromPerson = uniqueIDFromPerson; Title = title; LogoClass = logoClass; }
internal OAuth2Coordinator( AuthorizationServerDescription serverDescription, IAuthorizationServerHost authServerHost, TClient client, Action <TClient> clientAction, Action <AuthorizationServer> authServerAction) : base(clientAction, authServerAction) { Requires.NotNull(serverDescription, "serverDescription"); Requires.NotNull(authServerHost, "authServerHost"); Requires.NotNull(client, "client"); this.serverDescription = serverDescription; this.authServerHost = authServerHost; this.client = client; this.client.ClientIdentifier = OAuth2TestBase.ClientId; this.client.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(OAuth2TestBase.ClientSecret); }
public static WebServerClient CreateClient() { if (string.IsNullOrEmpty(AppSettings.OAuth2ClientIdentifier)) { Log.For(typeof(AccountController)).Error("OAuth2ClientIdentifier is not specified in configuration!"); throw new Exception("Authentication is incorrectly configured"); } if (string.IsNullOrEmpty(AppSettings.OAuth2ClientSecret)) { Log.For(typeof(AccountController)).Error("OAuth2ClientSecret is not specified in configuration!"); throw new Exception("Authentication is incorrectly configured"); } var desc = GetAuthServerDescription(); var client = new WebServerClient(desc, clientIdentifier: AppSettings.OAuth2ClientIdentifier); client.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(AppSettings.OAuth2ClientSecret); return(client); }
private IAuthorizationState GetAccessTokenFromOwnAuthSvr() { var server = new AuthorizationServerDescription { TokenEndpoint = new Uri(Config.ApiUrl + "/oauth/token"), ProtocolVersion = ProtocolVersion.V20 }; var client = new UserAgentClient(server) { //Those are the credentials for Downlords-FAF-Client ClientIdentifier = Config.ClientIdentifier, ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(Config.ClientCredentialApplicator) }; var token = client.ExchangeUserCredentialForToken( UsernameInputField.text, PasswordInputField.text); return(token); }
protected void btnGetToken_Click(object sender, EventArgs e) { Validate("vgAuthorize"); if (!Page.IsValid) { return; } try { ToSession(); WebServerClient consumer = new WebServerClient(Description(), CurrentPageState.ClientID, CurrentPageState.ClientSecret); consumer.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(CurrentPageState.ClientSecret); IAuthorizationState grantedAccess = consumer.ProcessUserAuthorization(new HttpRequestWrapper(Request)); lblToken.Text = grantedAccess.AccessToken; } catch (DotNetOpenAuth.Messaging.ProtocolException ex) { lblErr.Text = ex.Message; } }
public Uri GetAuthorizationUri() { _endPoint = "https://start.exactonline.com"; _authorization = new AuthorizationState { Callback = new Uri("http://localhost:19648/home/exoauth2") }; var serverDescription = new AuthorizationServerDescription { AuthorizationEndpoint = new Uri(string.Format("{0}/api/oauth2/auth", _endPoint)), TokenEndpoint = new Uri(string.Format("{0}/api/oauth2/token", _endPoint)) }; _oAuthClient = new UserAgentClient(serverDescription, "eb93389b-9532-46ca-9b24-898a38e91c22", "jYzWXVFiE87C"); _oAuthClient.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter("jYzWXVFiE87C"); return(_oAuthClient.RequestUserAuthorization(_authorization)); }
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"))); }
private bool getAccessToken(string authCode) { bool getSuccess = false; string accessToken = ""; if (RefreshKey_saved == "") { consumer.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(clientSecret); IAuthorizationState grantedAccess1 = consumer.ProcessUserAuthorization(authCode); accessToken = grantedAccess1.AccessToken; RefreshKey_real = grantedAccess1.RefreshToken; // save key iniParser parser = new iniParser(); parser.IniParser(iniPath); parser.AddSetting("Setup", "refreshkey", grantedAccess1.AccessToken); parser.AddSetting("Setup", "refreshkey_real", grantedAccess1.RefreshToken); parser.SaveSettings(); myTabControl.SelectedIndex = 0; } else { accessToken = RefreshKey_saved; myTabControl.SelectedIndex = 0; } try { GoogleApi api = new GoogleApi(accessToken); // string user = "******"; // api.GetEmail(); // GoogleApi api = new GoogleApi(accessToken); XmlDocument contacts = api.GetContacts(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(contacts.NameTable); // XmlNodeList _title = contacts.GetElementsByTagName("title"); string temp = _title.Item(0).InnerText; temp = temp.Replace("'s Contacts", ""); sender_name = temp; if (textbox_name.Text == "") { textbox_name.Text = temp; } nsmgr.AddNamespace("gd", "http://schemas.google.com/g/2005"); nsmgr.AddNamespace("a", "http://www.w3.org/2005/Atom"); emailCount = 0; foreach (XmlNode contact in contacts.GetElementsByTagName("entry")) { XmlNode title = contact.SelectSingleNode("a:title", nsmgr); XmlNode email = contact.SelectSingleNode("gd:email", nsmgr); // Console.WriteLine("{0}: {1}",title.InnerText, email.Attributes["address"].Value); if (email != null) { title_arr.Add(title.InnerText); gmail_arr.Add(email.Attributes["address"].Value); emailCount++; } } getSuccess = true; button_import.Visibility = Visibility.Collapsed; image_gmail.Visibility = System.Windows.Visibility.Visible; connected_gmail.Visibility = image_gmail.Visibility; myTabControl.SelectedIndex = 0; } catch (Exception err) { Console.WriteLine("Error: " + err.Message); getSuccess = false; return(getSuccess); } // everything is good, goto input : autocomplete contactData.inc(emailCount); int i = 0; foreach (string emailAddress in gmail_arr) { contactData.States.SetValue(emailAddress, i); i++; } int where = contactData.States.Length; // AutoCompleteBox.ItemsSource = contactData.States; //email_list.Items.Clear(); label_invalid.Visibility = Visibility.Collapsed; // myTabControl.SelectedIndex = 0; return(getSuccess); }
public override object Authenticate(IServiceBase authService, IAuthSession session, Authenticate request) { var tokens = this.Init(authService, ref session, request); //Transferring AccessToken/Secret from Mobile/Desktop App to Server if (request?.AccessToken != null) { if (VerifyAccessToken == null) { throw new NotImplementedException($"VerifyAccessToken is not implemented by {Provider}"); } if (!VerifyAccessToken(request.AccessToken)) { return(HttpError.Unauthorized($"AccessToken is not for the configured {Provider} App")); } var failedResult = AuthenticateWithAccessToken(authService, session, tokens, request.AccessToken); var isHtml = authService.Request.IsHtml(); if (failedResult != null) { return(ConvertToClientError(failedResult, isHtml)); } return(isHtml ? authService.Redirect(SuccessRedirectUrlFilter(this, session.ReferrerUrl.SetParam("s", "1"))) : null); //return default AuthenticateResponse } var authServer = new AuthorizationServerDescription { AuthorizationEndpoint = new Uri(this.AuthorizeUrl), TokenEndpoint = new Uri(this.AccessTokenUrl) }; AuthServerFilter?.Invoke(authServer); var authClient = new WebServerClient(authServer, this.ConsumerKey) { ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(this.ConsumerSecret), }; AuthClientFilter?.Invoke(authClient); var authState = ProcessUserAuthorization(authClient, authServer, authService); 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.Cookies.Add(cookie.ToCookie()); } } this.SaveSession(authService, session, SessionExpiry); return(httpResult); } catch (ProtocolException ex) { Log.Error("Failed to login to {0}".Fmt(this.Provider), ex); return(authService.Redirect(FailedRedirectUrlFilter(this, session.ReferrerUrl.SetParam("f", "Unknown")))); } } var accessToken = authState.AccessToken; if (accessToken != null) { tokens.RefreshToken = authState.RefreshToken; tokens.RefreshTokenExpiry = authState.AccessTokenExpirationUtc; } if (accessToken != null) { try { return(AuthenticateWithAccessToken(authService, session, tokens, accessToken) ?? authService.Redirect(SuccessRedirectUrlFilter(this, session.ReferrerUrl.SetParam("s", "1")))); } catch (WebException we) { var statusCode = ((HttpWebResponse)we.Response).StatusCode; if (statusCode == HttpStatusCode.BadRequest) { return(authService.Redirect(FailedRedirectUrlFilter(this, session.ReferrerUrl.SetParam("f", "AccessTokenFailed")))); } } } return(authService.Redirect(FailedRedirectUrlFilter(this, session.ReferrerUrl.SetParam("f", "RequestTokenFailed")))); }
public FBClient() : base(FacebookDescription) { ClientIdentifier = facebookAppID; ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(facebookAppSecret); }
public static IAuthProviderDefinition Facebook(string appId, string appSecret) { return(new OAuthProvider("{D8AEC9E8-9146-4789-86B4-8CC1AFFF3024}", "Facebook", "facebook.jpg", "https://graph.facebook.com/oauth/access_token", "https://graph.facebook.com/oauth/authorize", appId, ClientCredentialApplicator.PostParameter(appSecret))); }
public OAuthClient(AuthorizationServerDescription serverDescription, string clientId, string clientSecret, Uri redirectUri) : base(serverDescription, clientId, clientSecret) { _redirectUri = redirectUri; ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(clientSecret); }
public WeiboClient(AuthorizationServerDescription authorizationServer, string clientIdentifier, ClientCredentialApplicator clientCredentialApplicator) : base(authorizationServer, clientIdentifier, clientCredentialApplicator) { }