libs

Type Members

case class Jsonp(padding: String, json: JsValue) extends Product with Serializable

JSONP helper.
JSONP helper.
Example of use, provided the following route definition:
```
GET  /my-service       Application.myService(callback: String)
```
The following action definition:
```
def myService(callback: String) = Action {
  val json = ...
  Ok(Jsonp(callback, json))
}
```
And the following request:
```
GET /my-service?callback=foo
```
The response will have content type “text/javascript” and will look like the following:
```
foo({...});
```
Another example, showing how to serve either JSON or JSONP from the same action, according to the presence of a “callback” parameter in the query string:
```
def myService = Action { implicit request =>
  val json = ...
  request.queryString.get("callback").flatMap(_.headOption) match {
    case Some(callback) => Ok(Jsonp(callback, json))
    case None => Ok(json)
  }
}
```

Value Members

object Codecs

Utilities for Codecs operations.
object Collections

Utilities functions for Collections

object Comet

Helper function to produce a Comet using Akka Streams.

Please see https://en.wikipedia.org/wiki/Comet_(programming) for details of Comet.

Example:

def streamClock() = Action {
  val df: DateTimeFormatter = DateTimeFormatter.ofPattern("HH mm ss")
  val tickSource = Source.tick(0 millis, 100 millis, "TICK")
  val source = tickSource.map((tick) => df.format(ZonedDateTime.now()))
  Ok.chunked(source via Comet.flow("parent.clockChanged"))
}

object EventSource

This class provides an easy way to use Server Sent Events (SSE) as a chunked encoding, using an Akka Source.

Please see the Server-Sent Events specification for details.

An example of how to display an event stream:

import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter
import javax.inject.Singleton
import akka.stream.scaladsl.Source
import play.api.http.ContentTypes
import play.api.libs.EventSource
import play.api.mvc._

import scala.concurrent.duration._

def liveClock() = Action {
  val df: DateTimeFormatter = DateTimeFormatter.ofPattern("HH mm ss")
  val tickSource = Source.tick(0 millis, 100 millis, "TICK")
  val source = tickSource.map { (tick) =&gt;
    df.format(ZonedDateTime.now())
  }
  Ok.chunked(source via EventSource.flow).as(ContentTypes.EVENT_STREAM)
}

object Files

FileSystem utilities.
object JNDI

JNDI Helpers.
object Jsonp extends Serializable
package concurrent
package crypto
package functional

package json

Json API For example:

import play.api.libs.json._
import play.api.libs.functional.syntax._

case class User(id: Long, name: String, friends: Seq[User] = Seq.empty)
object User {

  // In this format, an undefined friends property is mapped to an empty list
  implicit val format: Format[User] = (
    (__ \ "id").format[Long] and
    (__ \ "name").format[String] and
    (__ \ "friends").lazyFormatNullable(implicitly[Format[Seq[User]]])
      .inmap[Seq[User]](_ getOrElse Seq.empty, Some(_))
  )(User.apply, unlift(User.unapply))
}

//then in a controller:

object MyController extends Controller {
   def displayUserAsJson(id: String) = Action {
      Ok(Json.toJson(User(id.toLong, "myName")))
   }
   def saveUser(jsonString: String)= Action {
     val user = Json.parse(jsonString).as[User]
     myDataStore.save(user)
     Ok
   }
}

package streams
package typedmap
package ws

Provides implicit type classes when you import the package.

package libs

Type Members

case class Jsonp(padding: String, json: JsValue) extends Product with Serializable

Value Members

object Codecs

object Collections

object Comet

object EventSource

object Files

object JNDI

object Jsonp extends Serializable

package concurrent

package crypto

package functional

package json

package streams

package typedmap

package ws

Inherited from AnyRef

Inherited from Any

Ungrouped