Providing a "Sign-in with Twitter" functionality using Scala

Table of contents

Reading Time: 3 minutes

Recently in one of our social projects that we are building with Lift 2.4, we had a requirement to sign in with Twitter amongst others like Facebook and Google. This post summarizes the work done step by step.

1) Create a Twitter App (if you do not have one already)

Follow the link https://dev.twitter.com/apps/new and create an app. Remember to enter a Callback URL (we missed this one and wasted an hour trying to debug). The Callback URL could be something like http://www..com/twitter/callback.

The significance of Callback URL is that, if you do not specify it, Twitter would disable callbacks.

Take a note of Consumer key wu5cUPDyBlaBla0rwRGww and
Consumer secret g9vuX4qb70iBlaBlaBlaDB2AjcYIJUtttx52TM

We would use them in our code.

2) In your build.sbt, make the following entry

 "org.twitter4j" % "twitter4j-core" % "[2.2,)"

as a library dependency.

3) If you are using eclipse, do sbt eclipse to get the Twitter4j dependencies. We are using Twitter4J, the unofficial Java library to access Twitter API

4) If you are using Lift, then add the keys in your default.props.

#login
#leisure twitter
twitter4j.oauth.consumerKey=wu5cUPDyBlaBla0rwRGww
twitter4j.oauth.consumerSecret=g9vuX4qb70iBlaBlaBlaDB2AjcYIJUtttx52TM

5) Let us now create a dispatcher which would handle the incoming requests

In our case we create an object TwitterDispatcher


/**
 * Handles user login via Twitter.
 */
object TwitterDispatcher extends Loggable {
}

6) The matcher is defined as following. If we get the URL as /twitter/authenticate then we call signUpRedirect and so on for other requests.

/**
   * Dispatch requests for twitter. We are interested in
   * twitter/authenticate, twitter/callback and twitter/logout
   */
  def matcher: LiftRules.DispatchPF = {
    case req @ Req("twitter" :: "authenticate" :: Nil, _, GetRequest) =>
      () => signUpRedirect(req)
    case req @ Req("twitter" :: "callback" :: Nil, _, GetRequest) =>
      () => processCallBack(req)
    case req @ Req("twitter" :: "logout" :: Nil, _, GetRequest) =>
      () => logout(req)
  }

7) signUpRedirect


/**
   * Calls Twitter API to authenticate the user.
   * Post authentication Twitter would send the token back on callbackURL
   * @See https://github.com/yusuke/sign-in-with-twitter/blob/master/src/main/java/twitter4j/examples/signin/SigninServlet.java
   */
  def signUpRedirect(req: Req): Box[LiftResponse] = {

    val twitter = (new TwitterFactory).getInstance
    twitter.setOAuthConsumer(Props.get("twitter4j.oauth.consumerKey").openOr(""),
      Props.get("twitter4j.oauth.consumerSecret").openOr(""))
    sessionTwitter.set(Full(twitter))

    // redirect to authentication URL
    try {
      val callbackURL = req.hostAndPath + "/twitter/callback"
      val requestToken = twitter.getOAuthRequestToken(callbackURL)
      sessionRequestToken.set(Full(requestToken))
      S.redirectTo(requestToken.getAuthenticationURL)
    } catch {
      case te: TwitterException => {
        if (401 == te.getStatusCode) { // Invalid credentials exception
          te.printStackTrace
          logger.info("Unable to get the access token.")
        } else {
          te.printStackTrace
        }
        S.error("Unable to login with twitter.")
        S.redirectTo("/")
      }
    }
  }

8) As you would see in the code, we pass a callBackURL when we are getting the request token

val requestToken = twitter.getOAuthRequestToken(callbackURL)

This tells twitter that once you are done with the authentication, pass back the results to the callbackURL which in our case is

val callbackURL = req.hostAndPath + "/twitter/callback"

9) Once we get a call back from twitter we get it on /twitter/callback which is mapped to processCallBack

/**
   * Call back from Twitter post authentication.
   * Login the authenticated user or 'create and login' new user.
   */
  def processCallBack(req: Req): Box[LiftResponse] = {

    (sessionTwitter.is, sessionRequestToken.is, req.param("oauth_verifier")) match {
      case (Full(twitter), Full(requestToken), Full(verifier)) => {
        try {
          twitter.getOAuthAccessToken(requestToken, verifier)
          sessionRequestToken.remove
          val tuser = twitter.verifyCredentials
          val userName = tuser.getScreenName
          val imageUrl = tuser.getProfileImageURL.toString
          logger.debug("Getting the twitter user as " + tuser)
          User.findByUsername(userName) match {
            case Empty => {
              // Create user in local database
              // Login user
              // redirect to home
            }
            case Full(user) => {
              // sessionNode.set(Full(user))
            }
            case _ =>
          }
          S.redirectTo("/")
        } catch {
          case e: TwitterException => {
            throw new Exception(e)
          }
        }
      }
      case _ => {
        S.error("Authentication error")
        S.redirectTo("/")
      }
    }
  }

10) You might want to store the twitter objects in session if you want and destroy them when the user logs out

 def logout(req: Req): Box[LiftResponse] = {

    sessionTwitter.remove
    sessionRequestToken.remove
    S.redirectTo("/")
  }

11)

object sessionTwitter extends SessionVar[Box[Twitter]](Empty)
object sessionRequestToken extends SessionVar[Box[RequestToken]](Empty)

Entire code can be found here https://gist.github.com/3175581

12) If you are using Lift, you need to tell lift that it should use the TwitterDispatcher. You do that by putting the following line in Boot.scala

 LiftRules.dispatch.append(TwitterDispatcher.matcher)

High performance systems

Data Engineering, Strategy and Analytics

Intelligence Driven Decisioning - AI/ML

Cloud Engineering

Architecture Strategy, Audit & Academy

Platforms

KDP

KDSP

Products

Premon

Studio9

Tech Hub

Akka

Scala

Rust

Spark

Functional Java

Kafka

Flink

ML/AI

DevOps

Data Warehouse

Travel

Retail

Finance

Healthcare

Media and Publishing

Consumer Internet

Hi-tech & IoT

Case Studies

Blogs

Books

Community

Resources

OS contributions

Webinars

Knolx

Check out our open positions

Services

Go to Overview

Accelerators

Go to Overview

Platforms

Products

TechHub

Industries

Go to Overview

Travel

Insights

Go to Overview

Providing a “Sign-in with Twitter” functionality using Scala

Share the Knol:

Related

Written by Vikas Hazrati

1 thought on “Providing a “Sign-in with Twitter” functionality using Scala4 min read”

COMPANY

Sign up to our newsletter

Certificates

Partners

© 2023 Knoldus, Inc. All Rights Reserved.

Part of NashTech

Privacy Policy | Sitemap

Discover more from Knoldus Blogs

Check out our
open positions