oauth.signpost.exception.OAuthMessageSignerException Java Examples

@Override
public Map<String, Object> check(TwitterSearchHistory tsh) throws RuntimeException, OAuthMessageSignerException, OAuthExpectationFailedException, OAuthCommunicationException, ClientProtocolException, IOException{
	Map<String, Object> map =new HashMap<String, Object>();
	//检查是否已经搜索过此内容或用户
	TwitterSearchHistoryExample example = new TwitterSearchHistoryExample();
	example.createCriteria().andSearchKeyEqualTo(tsh.getSearchKey())
							.andSearchTypeEqualTo(tsh.getSearchType());
	List<TwitterSearchHistory> list =twitterSearchHistoryMapper.selectByExample(example);
	SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); 
	if(null!=list&&list.size()>0){
		tsh =list.get(0);
	}
	if(null!=list&&list.size()>0&&sdf.format(list.get(0).getSearchDate()).compareTo(sdf.format(new Date()))==0){
		map.put("searchId", tsh.getId());
		map.put("status", Boolean.TRUE);
	}else{
		//今天没有搜索过，则调用推特api查询数据
		map = this.addTwitterPostByKey(tsh);
	}
	return map;
}
 

@Override
public HttpRequest sign(HttpRequest request, String key, String secret) throws LtiSigningException {
    CommonsHttpOAuthConsumer signer = new CommonsHttpOAuthConsumer(key, secret);
    try {
        String body = getRequestBody(request);
        String bodyHash = new String(Base64.encodeBase64(md.digest(body.getBytes())));

        HttpParameters params = new HttpParameters();
        params.put("oauth_body_hash", URLEncoder.encode(bodyHash, "UTF-8"));
        signer.setAdditionalParameters(params);

        signer.sign(request);
    } catch (OAuthMessageSignerException|OAuthExpectationFailedException|OAuthCommunicationException|IOException e) {
        throw new LtiSigningException("Exception encountered while singing Lti request...", e);
    }
    return request;
}
 

@Override
public String sign(HttpRequest request, HttpParameters requestParams)
    throws OAuthMessageSignerException {

  final OAuthRsaSigner signer = new OAuthRsaSigner();
  final byte[] privateBytes = Base64.decodeBase64(getConsumerSecret());
  final PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateBytes);

  try {
    signer.privateKey = KeyFactory.getInstance("RSA").generatePrivate(keySpec);
    final String signatureBaseString = new SignatureBaseString(request, requestParams).generate();
    return signer.computeSignature(signatureBaseString);
  } catch (GeneralSecurityException e) {
    throw new OAuthMessageSignerException(e);
  }
}
 

@Test
public void retrieveAccessToken_success() throws OAuthCommunicationException, OAuthExpectationFailedException, OAuthNotAuthorizedException, OAuthMessageSignerException {
    Uri uri = mock(Uri.class);
    String verifier = "some verifier";
    when(uri.getQueryParameter(OAuth.OAUTH_VERIFIER)).thenReturn(verifier);

    String userTokenString = "some token";
    when(okHttpOAuthConsumer.getToken()).thenReturn(userTokenString);

    String userTokenSecretString = "some secret token";
    when(okHttpOAuthConsumer.getTokenSecret()).thenReturn(userTokenSecretString);


    TestSubscriber testSubscriber = new TestSubscriber();
    oAuthInteractor.retrieveAccessToken(uri)
            .subscribe(testSubscriber);

    testSubscriber.assertCompleted();

    verify(okHttpOAuthProvider, times(1)).retrieveAccessToken(okHttpOAuthConsumer, verifier);
    verify(userToken, times(1)).set(userTokenString);
    verify(userTokenSecret, times(1)).set(userTokenSecretString);
}
 

@Override
public HttpRequest sign(HttpRequest request, String key, String secret) throws LtiSigningException {
    CommonsHttpOAuthConsumer signer = new CommonsHttpOAuthConsumer(key, secret);
    try {
        String body = getRequestBody(request);
        String bodyHash = new String(Base64.encodeBase64(md.digest(body.getBytes())));

        HttpParameters params = new HttpParameters();
        params.put("oauth_body_hash", URLEncoder.encode(bodyHash, "UTF-8"));
        signer.setAdditionalParameters(params);

        signer.sign(request);
    } catch (OAuthMessageSignerException|OAuthExpectationFailedException|OAuthCommunicationException|IOException e) {
        throw new LtiSigningException("Exception encountered while singing Lti request...", e);
    }
    return request;
}
 

public static String getAuthoriseAppUrl(Context context)
		throws OAuthMessageSignerException, OAuthNotAuthorizedException,
		OAuthExpectationFailedException, OAuthCommunicationException {

	/**
	 * You will want to set customProtocol to something unique to avoid
	 * having Android give the user more than one app to pick from to handle
	 * the oauth callback. A good option would be to use something derived
	 * from your package name.
	 */
	String customProtocol = context.getResources().getString(
			R.string.customAppProtocol);

	return provider.retrieveRequestToken(consumer, customProtocol
			+ "://oauth");
}
 

@Test
public void retrieveRequestToken_success() throws OAuthCommunicationException, OAuthExpectationFailedException, OAuthNotAuthorizedException, OAuthMessageSignerException {
    String token = "some token";
    when(okHttpOAuthProvider.retrieveRequestToken(any(), anyString())).thenReturn(token);

    TestSubscriber<String> testSubscriber = new TestSubscriber<>();
    oAuthInteractor.retrieveRequestToken()
            .subscribe(testSubscriber);

    testSubscriber.assertValue(token);
    verify(okHttpOAuthProvider, times(1)).retrieveRequestToken(okHttpOAuthConsumer, ApiConstants.OAUTH_CALLBACK);
}
 

@Test
public void retrieveRequestToken_error() throws OAuthCommunicationException, OAuthExpectationFailedException, OAuthNotAuthorizedException, OAuthMessageSignerException {
    Throwable throwable = new RuntimeException();
    when(okHttpOAuthProvider.retrieveRequestToken(any(), anyString())).thenThrow(throwable);

    TestSubscriber<String> testSubscriber = new TestSubscriber<>();
    oAuthInteractor.retrieveRequestToken()
            .subscribe(testSubscriber);

    testSubscriber.assertError(throwable);
    verify(okHttpOAuthProvider, times(1)).retrieveRequestToken(okHttpOAuthConsumer, ApiConstants.OAUTH_CALLBACK);
}
 

@Test
public void retrieveAccessToken_error() throws OAuthCommunicationException, OAuthExpectationFailedException, OAuthNotAuthorizedException, OAuthMessageSignerException {
    Uri uri = mock(Uri.class);
    when(uri.getQueryParameter(OAuth.OAUTH_VERIFIER)).thenReturn(null);

    TestSubscriber testSubscriber = new TestSubscriber();
    oAuthInteractor.retrieveAccessToken(uri)
            .subscribe(testSubscriber);

    // We don't really care what the error is just that we have one
    // Hacky way to see if there is an error (terminal event) but not success (completion)
    testSubscriber.assertTerminalEvent();
    testSubscriber.assertNotCompleted();
}
 

/**
 * Signs an HTTP post request for cases where OAuth 1.0 posts are
 * required instead of GET.
 *
 * @param unsignedUrl     - The unsigned URL
 * @param clientId        - The external provider assigned client id
 * @param clientSecret    - The external provider assigned client secret
 * @param token           - The access token
 * @param tokenSecret     - The 'secret' parameter to be used (Note: token secret != client secret)
 * @param oAuthParameters - Any additional parameters
 * @return The request to be signed and sent to external data provider.
 */
public static HttpRequestBase getSignedRequest(HttpMethod method,
                                               String unsignedUrl,
                                               String clientId,
                                               String clientSecret,
                                               String token,
                                               String tokenSecret,
                                               Map<String, String> oAuthParameters) throws ShimException {

    URL requestUrl = buildSignedUrl(unsignedUrl, clientId, clientSecret, token, tokenSecret, oAuthParameters);
    String[] signedParams = requestUrl.toString().split("\\?")[1].split("&");

    HttpRequestBase postRequest = method == HttpMethod.GET ?
        new HttpGet(unsignedUrl) : new HttpPost(unsignedUrl);
    String oauthHeader = "";
    for (String signedParam : signedParams) {
        String[] parts = signedParam.split("=");
        oauthHeader += parts[0] + "=\"" + parts[1] + "\",";
    }
    oauthHeader = "OAuth " + oauthHeader.substring(0, oauthHeader.length() - 1);
    postRequest.setHeader("Authorization", oauthHeader);
    CommonsHttpOAuthConsumer consumer = new CommonsHttpOAuthConsumer(clientId, clientSecret);
    consumer.setSendEmptyTokens(false);
    if (token != null) {
        consumer.setTokenWithSecret(token, tokenSecret);
    }
    try {
        consumer.sign(postRequest);
        return postRequest;
    } catch (
        OAuthMessageSignerException
            | OAuthExpectationFailedException
            | OAuthCommunicationException e) {
        e.printStackTrace();
        throw new ShimException("Could not sign POST request, cannot continue");
    }
}
 

private Error(OAuthException exception) {
    this.exception = exception;
    if (this.exception instanceof OAuthMessageSignerException) {
        this.type = Type.MESSAGE_SIGNER;
    } else if (this.exception instanceof OAuthNotAuthorizedException) {
        this.type = Type.NOT_AUTHORIZED;
    } else if (this.exception instanceof OAuthExpectationFailedException) {
        this.type = Type.EXPECTATION_FAILED;
    } else if (this.exception instanceof OAuthCommunicationException) {
        this.type = Type.COMMUNICATION;
    } else {
        this.type = Type.OTHER;
    }
    this.details = exception.getMessage();
}
 

public WSRequest sign(WSRequest request, String method) throws OAuthMessageSignerException, OAuthExpectationFailedException, OAuthCommunicationException {
    WSRequestAdapter req = (WSRequestAdapter)wrap(request);
    req.setMethod(method);
    sign(req);
    return request;
}
 

Map<String, Object> check(TwitterSearchHistory tsh) throws RuntimeException, OAuthMessageSignerException, OAuthExpectationFailedException, OAuthCommunicationException, ClientProtocolException, IOException;