Convenient class to generate extractors checking if a given mime type matches the Accept header of a request. Example of use:

val AcceptsMp3 = Accepting("audio/mp3")

Then:

request match {
  case AcceptsMp3() => ...
}

An action is essentially a (Request[A] => Result) function that handles a request and generates a result to be sent to the client.

For example,

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

A simple kind of ActionRefiner which, given a request (of type R), may either immediately produce a Result (for example, an error), or continue its Action block with the same request. The critical (abstract) function is filter.

A builder for generic Actions that generalizes over the type of requests. An ActionFunction[R,P] may be chained onto an existing ActionBuilder[R] to produce a new ActionBuilder[P] using andThen. The critical (abstract) function is invokeBlock. Most users will want to use ActionBuilder instead.

A simple kind of ActionFunction which, given a request (of type R), may either immediately produce a Result (for example, an error), or call its Action block with a parameter (of type P). The critical (abstract) function is refine.

A simple kind of ActionRefiner which, given a request (of type R), unconditionally transforms it to a new parameter type (P) to be passed to its Action block. The critical (abstract) function is transform.

Defines utility methods to generate Action and Results types.

For example:

class HomeController @Inject() (val controllerComponents: ControllerComponents) extends BaseController {

  def hello(name:String) = Action { request =>
    Ok("Hello " + name)
  }

}

This is intended to provide the idiomatic Play API for actions, allowing you to use "Action" for the default action builder and "parse" to access Play's default body parsers. You may want to extend this to provide your own base controller class, or write your own version with similar code.

Useful prewired mixins for controller components, assuming an available ControllerComponents.

If you want to extend your own AbstractController but want to use a different base "Action", you can mix in this trait.

A body parser parses the HTTP request body content.

Legacy body parsers trait. Basically all this does is define a "parse" member with a PlayBodyParsers instance constructed from the running app's settings. If no app is running, we create parsers using default settings and an internally-created materializer. This is done to support legacy behavior. Instead of using this trait, we suggest injecting an instance of PlayBodyParsers (either directly or through BaseController or one of its subclasses).

Defines a Call, which describes an HTTP request and can be used to create links or fill redirect data.

These values are usually generated by the reverse router.

A Codec handle the conversion of String to Byte arrays.

Useful mixins for controller classes.

If you wish to write a controller with minimal dependencies, you can mix in this trait, which includes helpers and useful constants.

class MyController @Inject() (action: DefaultActionBuilder, parse: PlayBodyParsers) extends ControllerHelpers {
  def index = action(parse.text) {
    Ok
  }
}

An HTTP cookie.

A trait representing the default action builder used by Play's controllers.

This trait is used for binding, since some dependency injection frameworks doesn't deal with types very well.

A cookie to be discarded. This contains only the data necessary for discarding a cookie.

An EssentialAction underlies every Action. Given a RequestHeader, an EssentialAction consumes the request body (an ByteString) and returns a Result.

An EssentialAction is a Handler, which means it is one of the objects that Play uses to handle requests.

Implement this interface if you want to add a Filter to your application

object AccessLog extends Filter {
  override def apply(next: RequestHeader => Future[Result])(request: RequestHeader): Future[Result] = {
		 val result = next(request)
		 result.map { r => play.Logger.info(request + "\n\t => " + r; r }
	 }
}

HTTP Flash scope.

Flash data are encoded into an HTTP cookie, and can only contain simple String values.

An Handler handles a request. Play understands several types of handlers, for example EssentialActions and WebSockets.

The Handler used to handle the request is controlled by GlobalSettings's onRequestReceived method. The default implementation of onRequestReceived delegates to onRouteRequest which calls the default Router.

Transform a value to a Javascript literal.

An abstract controller class that returns a MessagesRequest as the default Action.

An abstract implementation of MessagesBaseController to make it slightly easier to use.

class MyController @Inject()(cc: MessagesControllerComponents) extends MessagesAbstractController(cc) {
  def index = Action { implicit request: MessagesRequest[AnyContent] =>
    Ok(views.html.formTemplate(form)) // twirl template with form builders
  }
}

This trait is an ActionBuilder that provides a MessagesRequest to the block:

class MyController @Inject()(
  messagesAction: MessagesActionBuilder,
  cc: ControllerComponents
) extends AbstractController(cc) {
  def index = messagesAction { implicit request: MessagesRequest[AnyContent] =>
     Ok(views.html.formTemplate(form)) // twirl template with form builders
  }
}

This is useful when you don't want to have to add play.api.i18n.I18nSupport to a controller for form processing.

This class is a wrapped Request that is "i18n-aware" and can return the preferred messages associated with the request.

This trait is a RequestHeader that can provide a play.api.i18n.Messages instance.

This is very useful with when used for forms processing, as the form helpers defined in views.helper (e.g. inputText.scala.html) take a MessagesProvider.

Binder for URL path parameters.

You can provide an implementation of PathBindable[A] for any type A you want to be able to bind directly from the request path.

For example, given this class definition:

case class User(id: Int, name: String, age: Int)

You can define a binder retrieving a User instance from its id, useable like the following:

// In your routes:
// GET  /show/:user      controllers.Application.show(user)
// For example: /show/42

class HomeController @Inject() (val controllerComponents: ControllerComponents) extends BaseController {
  def show(user: User) = Action {
    ...
  }
}

The definition of binder can look like the following:

object User {
  implicit def pathBinder(implicit intBinder: PathBindable[Int]) = new PathBindable[User] {
    override def bind(key: String, value: String): Either[String, User] = {
      for {
        id <- intBinder.bind(key, value).right
        user <- User.findById(id).toRight("User not found").right
      } yield user
    }
    override def unbind(key: String, user: User): String = {
      intBinder.unbind(key, user.id)
    }
  }
}

Body parsers officially supported by Play (i.e. built-in to Play)

Binder for query string parameters.

You can provide an implementation of QueryStringBindable[A] for any type A you want to be able to bind directly from the request query string.

For example, if you have the following type to encode pagination:

/**
 * @param index Current page index
 * @param size Number of items in a page
 */
case class Pager(index: Int, size: Int)

Play will create a Pager(5, 42) value from a query string looking like /foo?p.index=5&p.size=42 if you define an instance of QueryStringBindable[Pager] available in the implicit scope.

For example:

object Pager {
  implicit def queryStringBinder(implicit intBinder: QueryStringBindable[Int]) = new QueryStringBindable[Pager] {
    override def bind(key: String, params: Map[String, Seq[String]]): Option[Either[String, Pager]] = {
      for {
        index <- intBinder.bind(key + ".index", params)
        size <- intBinder.bind(key + ".size", params)
      } yield {
        (index, size) match {
          case (Right(index), Right(size)) => Right(Pager(index, size))
          case _ => Left("Unable to bind a Pager")
        }
      }
    }
    override def unbind(key: String, pager: Pager): String = {
      intBinder.unbind(key + ".index", pager.index) + "&" + intBinder.unbind(key + ".size", pager.size)
    }
  }
}

To use it in a route, just write a type annotation aside the parameter you want to bind:

GET  /foo        controllers.foo(p: Pager)

Handle the request body a raw bytes data.

The complete HTTP request.

The HTTP request header. Note that it doesn’t contain the request body yet.

A simple result, which defines the response header and a body ready to send to the client.

HTTP Session.

Session data are encoded into an HTTP cookie, and can only contain simple String values.

Wrap an existing request. Useful to extend a request.

If you need to add extra values to a request, you could consider using request attributes instead. See the attr, withAttr, etc methods.

Implements deprecated controller functionality. We recommend moving away from this and using one of the classes or traits extending BaseController instead.