import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
private void configureOAuth20Client(final Collection<BaseClient> properties) {
    final AtomicInteger index = new AtomicInteger();
    casProperties.getAuthn().getPac4j().getOauth2()
            .stream()
            .filter(oauth -> StringUtils.isNotBlank(oauth.getId()) && StringUtils.isNotBlank(oauth.getSecret()))
            .forEach(oauth -> {
                final GenericOAuth20Client client = new GenericOAuth20Client();
                client.setKey(oauth.getId());
                client.setSecret(oauth.getSecret());
                client.setProfileAttrs(oauth.getProfileAttrs());
                client.setProfileNodePath(oauth.getProfilePath());
                client.setProfileUrl(oauth.getProfileUrl());
                client.setProfileVerb(Verb.valueOf(oauth.getProfileVerb().toUpperCase()));
                client.setTokenUrl(oauth.getTokenUrl());
                client.setAuthUrl(oauth.getAuthUrl());
                client.setCustomParams(oauth.getCustomParams());
                final int count = index.intValue();
                if (count > 0) {
                    client.setName(client.getClass().getSimpleName() + count);
                }
                index.incrementAndGet();
                LOGGER.debug("Created client [{}]", client);
                properties.add(client);
            });
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
public static void main (String[] args) {
    ResourceBundle secrets = ResourceBundle.getBundle("facebookutil/secret");
    final OAuth20Service service = new ServiceBuilder()
            .apiKey(secrets.getString("clientId"))
            .apiSecret(secrets.getString("clientSecret"))
            .callback("https://duke.edu/")
            .grantType("client_credentials")
            .build(FacebookApi.instance());
    String url = "https://graph.facebook.com/oauth/access_token?";
    url = url + "&client_id" + "=" + secrets.getString("clientId");
    url = url + "&client_secret" + "=" + secrets.getString("clientSecret");
    url = url + "&grant_type" + "=" + "client_credentials";
    final OAuthRequest request =
            new OAuthRequest(Verb.GET, url, service);
    service.signRequest(new OAuth2AccessToken(""), request);
    System.out.println(request.getBodyContents());
    System.out.println(request.getUrl());
    Response response = request.send();
    System.out.println(response.getBody());
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
@Override
public CredentialValidationResult validate(Credential credential) {
    if (credential instanceof TokenResponseCredential) {
        TokenResponseCredential tokenCredential = (TokenResponseCredential) credential;

        OAuthRequest request = new OAuthRequest(Verb.GET, "https://www.googleapis.com/oauth2/v3/userinfo");

        OAuth20Service service = tokenCredential.getService();
        OAuth2AccessToken token = tokenCredential.getTokenResponse();
        service.signRequest(token, request);

        try {
            Response oResp = service.execute(request);
            String body = oResp.getBody();

            OAuth2User oAuth2User = jsonProcessor.extractUserInfo(body);

            return new CredentialValidationResult(oAuth2User);

        } catch (InterruptedException | ExecutionException | IOException e) {
            e.printStackTrace(); // FIXME
        }

    }
    return CredentialValidationResult.NOT_VALIDATED_RESULT;
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
/**
 * Make a request to get the data of the authenticated user for the provider.
 *
 * @param accessToken the access token
 * @param dataUrl     url of the data
 * @param verb        method used to request data
 * @return the user data response
 */
protected CompletableFuture<String> sendRequestForData(final T accessToken, final String dataUrl, Verb verb) {
    logger.debug("accessToken: {} / dataUrl: {}", accessToken, dataUrl);
    final long t0 = System.currentTimeMillis();
    final OAuthRequestAsync request = createOAuthRequest(dataUrl, verb);
    signRequest(accessToken, request);
    final CompletableFuture<Response> responseFuture = new CompletableFuture<>();
    request.sendAsync(ScribeCallbackAdapter.toScribeOAuthRequestCallback(responseFuture));
    return responseFuture.thenApply(response -> {
        final int code = response.getCode();
        final String body;
        try {
            body = response.getBody();
        } catch (final IOException ex) {
            throw new HttpCommunicationException("Error getting body: " + ex.getMessage());
        }
        final long t1 = System.currentTimeMillis();
        logger.debug("Request took: " + (t1 - t0) + " ms for: " + dataUrl);
        logger.debug("response code: {} / response body: {}", code, body);
        if (code != 200) {
            throw new HttpCommunicationException(code, body);
        }
        return body;
    });
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
public OAuthProviderAccount loadOAuthProviderAccount(Token accessToken, OAuthProviderName provider) {
	OAuthService service = this.getService();

	// getting user profile
	OAuthRequest oauthRequest = new OAuthRequest(Verb.GET, config.getProfileUrl(), service);
	service.signRequest(accessToken, oauthRequest); // the access token from step 4

	Response oauthResponse = oauthRequest.send();

	String jsonString = oauthResponse.getBody();
	JSONObject root = new JSONObject(jsonString);

	String accountId = String.valueOf(root.getInt(TWITTER_ACCTID_PROPERTY)); 
	String displayName = root.getString(TWITTER_DISPLAYNAME_PROPERTY);
	String publicId = root.getString(TWITTER_SCREENNAME_PROPERTY); 
	String profilePath = provider.getIdProviderUrl() + "/" + publicId; 
	
	OAuthProviderAccount profile = 
			new OAuthProviderAccount(accessToken, provider, displayName, accountId, publicId , profilePath);

	return profile;
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
protected AccountData doInBackground(Void... voids) {
    AccountData aData = new AccountData();

    //Build the OAuth service
    final OAuth10aService service = new ServiceBuilder()
            .apiKey(apiKeys.CONSUMER_KEY)
            .apiSecret(apiKeys.CONSUMER_SECRET)
            .build(TradeKingApi.instance());
    Token accessToken = new Token(apiKeys.OAUTH_TOKEN, apiKeys.OAUTH_TOKEN_SECRET);

    // Fetch the JSON data
    OAuthRequest request = new OAuthRequest(Verb.GET, tk.getFullAccountInfo(), service);
    service.signRequest(accessToken, request);
    Response response = request.send();

    //parse json
    try {
        aData = parseJSON(response);
    } catch (JSONException e) {
        e.printStackTrace();
        aData.setError(e.toString());
    }

    return aData;
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
protected StockQuote doInBackground(Void... voids){
    //pause for a second so we don't get rate limited
    SystemClock.sleep(1000);

    //Build the OAuth service
    final OAuth10aService service = new ServiceBuilder()
            .apiKey(apiKeys.CONSUMER_KEY)
            .apiSecret(apiKeys.CONSUMER_SECRET)
            .build(TradeKingApi.instance());
    Token accessToken = new Token(apiKeys.OAUTH_TOKEN, apiKeys.OAUTH_TOKEN_SECRET);

    // Fetch the JSON data
    OAuthRequest request = new OAuthRequest(Verb.GET, tk.getMarketQuote(symbol), service);
    service.signRequest(accessToken, request);
    Response response = request.send();

    StockQuote quote = new StockQuote(symbol);
    try {
        quote = parseJSON(response);
    } catch (JSONException e) {
        e.printStackTrace();
        quote.setError(e.toString());
    }

    return quote;
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
protected Double doInBackground(Void... voids){
    double ret = 0.0;

    //Build the OAuth service
    final OAuth10aService service = new ServiceBuilder()
            .apiKey(apiKeys.CONSUMER_KEY)
            .apiSecret(apiKeys.CONSUMER_SECRET)
            .build(TradeKingApi.instance());
    Token accessToken = new Token(apiKeys.OAUTH_TOKEN, apiKeys.OAUTH_TOKEN_SECRET);

    // Fetch the JSON data
    OAuthRequest request = new OAuthRequest(Verb.GET, tk.getOptionStrikePrices(symbol), service);
    service.signRequest(accessToken, request);
    Response response = request.send();

    try {
        ret = parseJSON(response);
    } catch (JSONException e) {
        e.printStackTrace();
    }

    return ret;
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
protected OptionOrder doInBackground(Void... voids){
    OptionOrder order = new OptionOrder();

    //Build the OAuth service
    final OAuth10aService service = new ServiceBuilder()
            .apiKey(apiKeys.CONSUMER_KEY)
            .apiSecret(apiKeys.CONSUMER_SECRET)
            .build(TradeKingApi.instance());
    Token accessToken = new Token(apiKeys.OAUTH_TOKEN, apiKeys.OAUTH_TOKEN_SECRET);

    // Fetch the JSON data
    OAuthRequest request = new OAuthRequest(Verb.POST, tk.getMarketOptionLive(), service);
    //request.addHeader("TKI_OVERRIDE", "true");
    request.addPayload(fixml.getLimitFixmlString());
    service.signRequest(accessToken, request);
    Response response = request.send();

    try {
        order = parseJSON(response);
    } catch (JSONException e) {
        e.printStackTrace();
        order.setError(e.toString());
    }

    return order;
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
protected OptionOrderPreview doInBackground(Void... voids){
    OptionOrderPreview order = new OptionOrderPreview();

    //Build the OAuth service
    final OAuth10aService service = new ServiceBuilder()
            .apiKey(apiKeys.CONSUMER_KEY)
            .apiSecret(apiKeys.CONSUMER_SECRET)
            .build(TradeKingApi.instance());
    Token accessToken = new Token(apiKeys.OAUTH_TOKEN, apiKeys.OAUTH_TOKEN_SECRET);

    // Fetch the JSON data
    OAuthRequest request = new OAuthRequest(Verb.POST, tk.getMarketOptionPreview(), service);
    request.addPayload(fixml.getMarketFixmlString());
    service.signRequest(accessToken, request);
    Response response = request.send();

    try {
        order = parseJSON(response);
    } catch (JSONException e) {
        e.printStackTrace();
        order.setError(e.toString());
    }

    return order;
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
private void processRequest(HttpServletRequest req, HttpServletResponse resp) throws IOException {
	String code = req.getParameter("code");
	LOGGER.info("OAuth2 code: [{}]", code);
	String provider = StringUtils.substringAfterLast(req.getRequestURI(), "/");
	LOGGER.info("Provider: [{}]", provider);
	OAuth20Service oAuth2Service = this.providerFactory.getOAuth2Service(provider);
	OAuth2AccessToken token = null;
	try {
		token = oAuth2Service.getAccessToken(code);
		LOGGER.info("OAuth2AccessToken: [{}]", token);
		OAuthRequest oReq = new OAuthRequest(Verb.GET, "https://api.linkedin.com/v1/people/~?format=json");
		oAuth2Service.signRequest(token, oReq);
		Response oResp = oAuth2Service.execute(oReq);
		LOGGER.info("Linkedin Profile: [{}]", oResp.getBody());
		resp.getOutputStream().write(oResp.getBody().getBytes(StandardCharsets.UTF_8));
	} catch (InterruptedException | ExecutionException ex) {
	}
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
/**
 * Verify account credentials against the Twitter API
 */
private void verfiyAccountCredentials() throws TwitterException {
    OAuthRequest verifyRequest = createOAuthRequest(Verb.GET, VERIFY_CREDENTIALS_URL);
    signRequest(verifyRequest);

    try {
        Response response = service.execute(verifyRequest);
        if (response.getMessage().toLowerCase().equals("Too Many Requests")) {
            throw new TwitterException("Too many requests for this account.");
        } else if (!response.getMessage().toLowerCase().equals("ok")) {
            throw new TwitterException("Invalid twitter configuration");
        }
    } catch (IOException | ExecutionException | InterruptedException e) {
        throw new TwitterException("Could not verify account credentials.");
    }
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
static public OAuthRequest getRequestForProvider(
  final String providerName,
  final Verb httpVerb,
  final OAuth1AccessToken oa1token,
  final URL url,
  final HashMap<String,Object> cfg,
  @Nullable final ReadableMap params
) {
  final OAuth10aService service =
        OAuthManagerProviders.getApiFor10aProvider(providerName, cfg, null, null);

  String token = oa1token.getToken();
  OAuthConfig config = service.getConfig();
  OAuthRequest request = new OAuthRequest(httpVerb, url.toString(), config);

  request = OAuthManagerProviders.addParametersToRequest(request, token, params);
  // Nothing special for Twitter
  return request;
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
/**
 * Check to see that login is a member of organization.
 *
 * A 204 response code indicates organization membership.  302 and 404 codes are not treated as exceptional,
 * they indicate various ways in which a login is not a member of the organization.
 *
 * @see <a href="https://developer.github.com/v3/orgs/members/#response-if-requester-is-an-organization-member-and-user-is-a-member">GitHub members API</a>
 */
private boolean isOrganizationMember(OAuth2AccessToken accessToken, String organization, String login) throws IOException, ExecutionException, InterruptedException {
  String requestUrl = settings.apiURL() + format("orgs/%s/members/%s", organization, login);
  OAuth20Service scribe = new ServiceBuilder(settings.clientId())
    .apiSecret(settings.clientSecret())
    .build(scribeApi);
  OAuthRequest request = new OAuthRequest(Verb.GET, requestUrl);
  scribe.signRequest(accessToken, request);

  Response response = scribe.execute(request);
  int code = response.getCode();
  switch (code) {
    case HttpURLConnection.HTTP_MOVED_TEMP:
    case HttpURLConnection.HTTP_NOT_FOUND:
    case HttpURLConnection.HTTP_NO_CONTENT:
      LOGGER.trace("Orgs response received : {}", code);
      return code == HttpURLConnection.HTTP_NO_CONTENT;
    default:
      throw unexpectedResponseCode(requestUrl, response);
  }
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
public String getSingleUseToken() {
    OAuth10aService service = JamAuthConfig.instance().getOAuth10aService();
    final OAuthRequest request = new OAuthRequest(Verb.POST,
            JamAuthConfig.instance().getServerUrl() + "/v1/single_use_tokens",
            service);
    service.signRequest(JamAuthConfig.instance().getOAuth10aAccessToken(), request);

    final Response response = request.send();
    String body = response.getBody();

    Matcher matcher = SINGLE_USE_TOKEN_PATTERN.matcher(body);
    if (matcher.find()) {
        return matcher.group(0);
    }
    return null;
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
/**
 * This method must be called before signing the request. The converted request url is obtained
 * by concatenation of elemments of the url. The converted url contains the HTTP verb, the base
 * url and all the parameters sorted by alphabetical order
 * @param baseUrl base url for the request
 * @param httpVerb request type (GET or POST)
 * @param params request params (key : param's name, value : param's value
 * @return A converted url with following format: GET&url&param with escaped characters
 */
public static String convertUrl(String baseUrl, Verb httpVerb, Map<String, String> params) {
    try {
        StringBuilder urlBuilder = new StringBuilder(httpVerb.name())
                .append(SEPARATOR)
                .append(URLEncoder.encode(baseUrl, UTF_8))
                .append(SEPARATOR);

        StringBuilder paramsBuilder = new StringBuilder();
        for (Map.Entry<String, String> param : params.entrySet()) {
            paramsBuilder.append(param.getKey()).append(EQUAL).append(param.getValue()).append(SEPARATOR);
        }

        int lastIndexSep = paramsBuilder.lastIndexOf(SEPARATOR);
        String urlToEncode = (lastIndexSep >= 0) ? paramsBuilder.deleteCharAt(lastIndexSep).toString() : paramsBuilder.toString();
        String paramsEncoded = URLEncoder.encode(urlToEncode, UTF_8);
        return urlBuilder.append(paramsEncoded).toString();
    } catch (UnsupportedEncodingException e) {
        return null;
    }
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
/**
 * This method must be called before signing the request. The converted request url is obtained
 * by concatenation of elemments of the url. The converted url contains the HTTP verb, the base
 * url and all the parameters sorted by alphabetical order
 *
 * @param baseUrl  base url for the request
 * @param httpVerb request type (GET or POST)
 * @param params   request params (key : param's name, value : param's value
 * @return A converted url with following format: GET&url&param with escaped characters
 */
public static String convertUrl(String baseUrl, Verb httpVerb, Map<String, String> params) {
    try {
        StringBuilder urlBuilder = new StringBuilder(httpVerb.name())
                .append(SEPARATOR)
                .append(URLEncoder.encode(baseUrl, "UTF-8"))
                .append(SEPARATOR);

        StringBuilder paramsBuilder = new StringBuilder();
        Set<Map.Entry<String, String>> values = params.entrySet();
        for (Map.Entry<String, String> param : values) {
            paramsBuilder.append(param.getKey()).append(EQUAL).append(param.getValue()).append(SEPARATOR);
        }

        String paramsEncoded = URLEncoder.encode(paramsBuilder.deleteCharAt(paramsBuilder.lastIndexOf(SEPARATOR)).toString(), "UTF-8");
        return urlBuilder.append(paramsEncoded).toString();
    } catch (UnsupportedEncodingException e) {
        return null;
    }
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
public static OAuthRequest getOAuthRequest(LoginPreferences loginPreferences, String requestUrl, Verb verb) {

        Map<String, String> oAuthParams = loginPreferences.retrieveOAuthParams();
        if (oAuthParams != null) {
            OAuthRequest oAuthRequest = new OAuthRequest(oAuthParams.get(CONSUMER_PARAM), oAuthParams.get(CONSUMER_SECRET_PARAM));
            oAuthRequest.initParam(OAuthParams.getOAuthParams().put(TOKEN_PARAM, oAuthParams.get(TOKEN_PARAM)).toMap());
            oAuthRequest.setOAuthToken(oAuthParams.get(TOKEN_PARAM));
            oAuthRequest.setOAuthTokenSecret(oAuthParams.get(TOKEN_SECRET_PARAM));
            oAuthRequest.setRequestUrl(requestUrl);
            oAuthRequest.signRequest(verb);
            oAuthRequest.encodeParams();
            return oAuthRequest;
        } else {
            return null;
        }
    }
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
public static Verb getMethod(String method) {
	switch (method) {
		case "GET":
			return Verb.GET;
		case "POST":
			return Verb.POST;
		case "DELETE":
			return Verb.DELETE;
		case "PUT":
			return Verb.PUT;
		case "PATCH":
			return Verb.PATCH;
		case "OPTIONS":
			return Verb.OPTIONS;
	}
	throw new IllegalStateException(method);
}
 

import com.github.scribejava.core.model.Verb; //导入依赖的package包/类
@Override
public void createChallenge (App application, UserProfile target, String message) {
    if (target == null) {
        new ErrorMessage(ERROR).showError();
        return;
    }
    OAuthRequest myRequest = new OAuthRequest(Verb.POST,
                                              String.format(CHALLENGE_URL, target.getID()),
                                              application.getLogin().getService());
    myRequest.addBodyParameter("message", message);
    setRequest(myRequest);
}