class AuthenticatedBuilder[U] extends ActionBuilder[[A]AuthenticatedRequest[A, U], AnyContent]

An authenticated action builder.

This can be used to create an action builder, like so:

class UserAuthenticatedBuilder (parser: BodyParser[AnyContent])(implicit ec: ExecutionContext)
  extends AuthenticatedBuilder[User]({ req: RequestHeader =>
  req.session.get("user").map(User)
}, parser) {
  @Inject()
  def this(parser: BodyParsers.Default)(implicit ec: ExecutionContext) = {
    this(parser: BodyParser[AnyContent])
  }
}

You can then use the authenticated builder with other action builders, i.e. to use a messagesApi with authentication, you can add:

 class AuthMessagesRequest[A](val user: User,
                             messagesApi: MessagesApi,
                             request: Request[A])
extends MessagesRequest[A](request, messagesApi)

class AuthenticatedActionBuilder(val parser: BodyParser[AnyContent],
                                 messagesApi: MessagesApi,
                                 builder: AuthenticatedBuilder[User])
                                (implicit val executionContext: ExecutionContext)
    extends ActionBuilder[AuthMessagesRequest, AnyContent] {
  type ResultBlock[A] = (AuthMessagesRequest[A]) => Future[Result]

  @Inject
  def this(parser: BodyParsers.Default,
           messagesApi: MessagesApi,
           builder: UserAuthenticatedBuilder)(implicit ec: ExecutionContext) = {
    this(parser: BodyParser[AnyContent], messagesApi, builder)
  }

  def invokeBlock[A](request: Request[A], block: ResultBlock[A]): Future[Result] = {
    builder.authenticate(request, { authRequest: AuthenticatedRequest[A, User] =>
      block(new AuthMessagesRequest[A](authRequest.user, messagesApi, request))
    })
  }
}
Source
Security.scala
Linear Supertypes
ActionBuilder[[A]AuthenticatedRequest[A, U], AnyContent], ActionFunction[Request, [A]AuthenticatedRequest[A, U]], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. AuthenticatedBuilder
  2. ActionBuilder
  3. ActionFunction
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new AuthenticatedBuilder(userinfo: (RequestHeader) => Option[U], defaultParser: [AnyContent], onUnauthorized: () => Result = implicit request => Unauthorized(views.html.defaultpages.unauthorized()))(implicit executionContext: ExecutionContext)

    userinfo

    The function that looks up the user info.

    onUnauthorized

    The function to get the result for when no authenticated user can be found.

Value Members

  1. def andThen[Q[_]](other: [[A]AuthenticatedRequest[A, U], Q]): ActionBuilder[Q, AnyContent]

    Compose this ActionFunction with another, with this one applied first.

    Compose this ActionFunction with another, with this one applied first.

    other

    ActionFunction with which to compose

    returns

    The new ActionFunction

    Definition Classes
    → ActionFunction
  2. final def apply(block: => Result): [AnyContent]

    Constructs an Action with default content, and no request parameter.

    Constructs an Action with default content, and no request parameter.

    For example:

    val hello = Action {
  Ok("Hello!")
}
    block

    the action code

    returns

    an action

    Definition Classes
    ActionBuilder
  3. final def apply(block: ([AnyContent, U]) => Result): [AnyContent]

    Constructs an Action with default content.

    Constructs an Action with default content.

    For example:

    val echo = Action { request =>
  Ok("Got request [" + request + "]")
}
    block

    the action code

    returns

    an action

    Definition Classes
    ActionBuilder
  4. final def apply[A](bodyParser: BodyParser[A]): [[A]AuthenticatedRequest[A, U], A]

    Constructs an with the given BodyParser.

    Constructs an with the given BodyParser. The result can then be applied directly to a block.

    For example:

    val echo = Action(parse.anyContent) { request =>
  Ok("Got request [" + request + "]")
}
    A

    the type of the request body

    bodyParser

    the BodyParser to use to parse the request body

    returns

    an action

    Definition Classes
    ActionBuilder
  5. final def async[A](bodyParser: BodyParser[A])(block: (AuthenticatedRequest[A, U]) => Future[Result]): Action[A]

    Constructs an Action with the given BodyParser that returns a future of a result.

    Constructs an Action with the given BodyParser that returns a future of a result.

    For example:

    val hello = Action.async(parse.anyContent) { request =>
  ws.url(request.getQueryString("url").get).get().map { r =>
    if (r.status == 200) Ok("The website is up") else NotFound("The website is down")
  }
}
    block

    the action code

    returns

    an action

    Definition Classes
    ActionBuilder
  6. final def async(block: ([AnyContent, U]) => Future[Result]): [AnyContent]

    Constructs an Action that returns a future of a result, with default content.

    Constructs an Action that returns a future of a result, with default content.

    For example:

    val hello = Action.async { request =>
  ws.url(request.getQueryString("url").get).get().map { r =>
    if (r.status == 200) Ok("The website is up") else NotFound("The website is down")
  }
}
    block

    the action code

    returns

    an action

    Definition Classes
    ActionBuilder
  7. final def async(block: => Future[Result]): [AnyContent]

    Constructs an Action that returns a future of a result, with default content, and no request parameter.

    Constructs an Action that returns a future of a result, with default content, and no request parameter.

    For example:

    val hello = Action.async {
  ws.url("http://www.playframework.com").get().map { r =>
    if (r.status == 200) Ok("The website is up") else NotFound("The website is down")
  }
}
    block

    the action code

    returns

    an action

    Definition Classes
    ActionBuilder
  8. def authenticate[A](request: Request[A], block: (AuthenticatedRequest[A, U]) => Future[Result]): Future[Result]

    Authenticate the given block.

  9. def compose[B](other: [Request, B]): [[A]AuthenticatedRequest[A, U], B]
    Definition Classes
    ActionFunction
  10. def compose[Q[_]](other: ActionFunction[Q, Request]): ActionFunction[Q, [A]AuthenticatedRequest[A, U]]

    Compose another ActionFunction with this one, with this one applied last.

    Compose another ActionFunction with this one, with this one applied last.

    other

    ActionFunction with which to compose

    returns

    The new ActionFunction

    Definition Classes
    ActionFunction
  11. implicit val executionContext: ExecutionContext

    returns

    The execution context to run the request in.

    Definition Classes
    → ActionFunction
  12. def invokeBlock[A](request: Request[A], block: (AuthenticatedRequest[A, U]) => Future[Result]): Future[Result]

    Invoke the block.

    Invoke the block. This is the main method that an ActionBuilder has to implement, at this stage it can wrap it in any other actions, modify the request object or potentially use a different class to represent the request.

    request

    The request

    block

    The block of code to invoke

    returns

    A future of the result

    Definition Classes
    → ActionFunction
  13. lazy val parser: [AnyContent]

    returns

    The BodyParser to be used by this ActionBuilder if no other is specified

    Definition Classes
    → ActionBuilder