Scala RequestToken类代码示例

//设置package包名称以及导入依赖的类
package actors

import play.api.Configuration
import play.api.libs.oauth.{ConsumerKey, RequestToken}

trait TwitterCredentials {
  val config: Configuration

  protected def credentials: Option[(ConsumerKey, RequestToken)] = for {
    apiKey <- config.getString("twitter.apiKey")
    apiSecret <- config.getString("twitter.apiSecret")
    token <- config.getString("twitter.token")
    tokenSecret <- config.getString("twitter.tokenSecret")
  } yield (
    ConsumerKey(apiKey, apiSecret),
    RequestToken(token, tokenSecret)
    )
} 

//设置package包名称以及导入依赖的类
package models

import controllers.{GoodReadsApi, ApiAuth}
import org.junit.runner.RunWith
import org.specs2.mutable._
import org.specs2.runner.JUnitRunner
import play.api.libs.oauth.{RequestToken}
import play.api.test.WithApplication

import scala.concurrent.Await
import scala.concurrent.duration._

@RunWith(classOf[JUnitRunner])
class GoodReadsSpec extends Specification {

  val testTokenKey = "8JREwkwPJkEVT4ITYwpNRA"
  val testTokenSecret = "GdLeeyowGPcGXLfIQarxjD1hWawXclz50Gus126qNvc"
  val requestToken = RequestToken(testTokenKey, testTokenSecret)

  "GoodReads current user" should {
    "return current user id" in new WithApplication {
      val api = new GoodReadsApi(new ApiAuth())

      val goodReadsUser = Await.result(api.getCurrentUser(requestToken), 5 seconds)

      goodReadsUser.id must not beNull
    }
  }

  "GoodReads review list" should {
    "return list of reviews" in new WithApplication {
      val goodReadsApi = new GoodReadsApi(new ApiAuth())

      val books = Await.result(goodReadsApi.getBooks("52427719", requestToken), 5 seconds)

      books.length must beGreaterThan(0)
      books.head.title must not beNull
    }
  }
} 

//设置package包名称以及导入依赖的类
package controllers

import javax.inject.Inject

import play.api.libs.oauth.{ConsumerKey, OAuth, RequestToken, ServiceInfo}
import play.api.{Configuration, Play}
import play.api.libs.ws.WSClient
import play.api.mvc.{Action, Controller, RequestHeader}

class Twitter @Inject()(ws: WSClient, configuration: Configuration) extends Controller {

  val oauth = OAuth(ServiceInfo(
    "https://api.twitter.com/oauth/request_token",
    "https://api.twitter.com/oauth/access_token",
    "https://api.twitter.com/oauth/authorize", credentials.get),
    true)

  private val credentials = for {
    apiKey <- configuration.getString("twitter.apikey")
    apiSecret <- configuration.getString("twitter.apisecret")
    callbackUrl <- configuration.getString("twitter.callbackUrl")
  } yield ConsumerKey(apiKey, apiSecret)

  def sessionTokenPair(implicit request: RequestHeader): Option[RequestToken] = {
    for {
      token <- request.session.get("token")
      secret <- request.session.get("secret")
    } yield {
      RequestToken(token, secret)
    }
  }

  def authenticate = Action { request =>
    request.getQueryString("oauth_verifier").map { verifier =>
      val tokenPair = sessionTokenPair(request).get
      // We got the verifier; now get the access token, store it and back to index
      oauth.retrieveAccessToken(tokenPair, verifier) match {
        case Right(t) => {
          // We received the authorized tokens in the OAuth object - store it before we proceed
          Redirect(routes.Twitter.index).withSession("token" -> t.token, "secret" -> t.secret)
        }
        case Left(e) => throw e
      }
    }.getOrElse(
      oauth.retrieveRequestToken("https://localhost:9000/auth") match {
        case Right(t) => {
          // We received the unauthorized tokens in the OAuth object - store it before we proceed
          Redirect(oauth.redirectUrl(t.token)).withSession("token" -> t.token, "secret" -> t.secret)
        }
        case Left(e) => throw e
      })
  }


  def topArtists = Action {
    Ok
  }

}