Question

I need to check for the existence of a YMD uri date param on every request, and, if exist, store it in the Request for later access in various parts of the application where implicit request has been made available.

Request interception seems an obvious choice:
https://github.com/playframework/Play20/wiki/ScalaInterceptors

However, I am not seeing a way to add to the Request (actually RequestHeader is what’s available), assume it’s read only/immutable.

I am able to add data to the Request via Action Composition; however, this approach is limited to the composed action, and not every action (why I’d like the above global Before Interceptor approach to somehow work). For example, an Authentiucated action wrapper allows me to store the logged in user’s id in the Request.

trait Secured { 
  private case class Success[A](uid: Int, r: Request[A]) extends WrappedRequest(r)

  def Authenticated[A](p: BodyParser[A])
    (f: Success[A] => Result)(implicit group: RoleGroup) = {

    def apply(maybeUser: Option[String])(implicit r: Request[A]) = {
      maybeUser map {id =>
        Cache.orElse(group.to_s+"-"+id, 3600){
          repo.user.get(id.int, group) map(_.active) getOrElse false
      } fold ( onFail, f(Success(id.int, r)) )
    }
  }

I would like to do the same for a possible uri date param, but have it apply to all Actions, or, again, have it applied before the Play routes mechanism is triggered via global interceptor.

Ideas much appreciated, thanks

Answer 1

To simulate injecting arbitrary data into the Request, you can extend WrappedRequest:

case class Outcome[A](
  r: Request[A], 
  uid: Int, 
  startDate: String,
  endDate: String,
  uriDate: JodaTime) extends WrappedRequest(r)

and then create Action provider traits that return an instance of your custom request wrapper. For example, a base Task action could look like:

trait TaskRequest 
  extends DateParser {

  def Task[A](p: BodyParser[A])(f: Outcome[A] => Result) = {
    Action(p) { implicit r =>
      f( toOutcome[A](r, r.session.get("userID").map(_.toInt) getOrElse 0) )
    }
  }
  def Task(f: Outcome[AnyContent] => Result): Action[AnyContent] = {
    import play.api.mvc.BodyParsers._
    Task(parse.anyContent)(f)
  }

  protected def toOutcome[A](r: Request[A], uid: Int) = {
    val(start,uriDate) = (startDate(r), toDate(r.uri))
    val end = seasonEnd(start)
    Outcome(r, uid, start.toString("yyyyMMdd"), end.toString("yyyyMMdd"), uriDate)
  }

  val ymdMatcher = "\\d{8}".r  
  protected def startDate(uri: String) = {
    ymdMatcher.findFirstIn(uri). // set season start based on ymd URI param if exist 
    map(_.startDate) getOrElse seasonStart(new JodaTime)
  }

  protected def toDate(uri: String) =
    ymdMatcher.findFirstIn(r.uri).map(_.to_date) getOrElse new JodaTime
}

and then derive an Authenticated action from Task:

trait Secured
  extends TaskRequest { 

  def Authenticated[A](p: BodyParser[A])
    (f: Outcome[A] => Result)(implicit group: RoleGroup) = {

    def apply(maybeUser: Option[String])(implicit r: Request[A]) = {
      maybeUser map {id =>
        Cache.orElse(group.to_s+"-"+id, 3600){
          repo.user.get(id.int, group) map(_.active) getOrElse false
      } fold ( onFail, f( toOutcome(r, id.int)) )
    }
  }

and then use in your controllers:

def index = Authenticated { implicit request=>
  // voila, current season start date since no uri date param exist
  request.startDate
}

I could call the date manipulations functions on a per action basis, sure, but that would only apply to Action scope. How would I access the startDate in the template layer? I couldn’t, but with a custom request wrapper you can inject anything you want and easily reference the data anywhere. So instead of bringing play’s request into scope:

@(model: Foo, title: String)(implicit request: play.api.mvc.Request[_])

you reference your custom request wrapper:

@(model: Foo, title: String)(implicit request: controllers.Outcome[_])

Does the job quite nicely, global interception I have yet to find a use for (maybe re-route some legacy URIs, but nothing as powerful as the WrappedRequest approach)