InternalRedirectToPost.scala

object RedirectFilter extends Filter {

  def apply(next: RequestHeader => Result)(request: RequestHeader): Result = {

    getRedirectParams(request).flatMap { case (newRequest, body) =>
      route(newRequest).map { iteratee =>
        AsyncResult(Enumerator(body).run(iteratee))
      }
    } getOrElse {
      next(request)
    }
  }

  private def getRedirectParams(request: RequestHeader): Option[(RequestHeader, Array[Byte])] = {
    if (someCondition) {
      Some(toPostRequest(request), "Some new body data".getBytes("UTF-8"))      
    } else {
      None
    }
  }

  private def toPostRequest(originalRequest: RequestHeader): RequestHeader = {
    originalRequest.copy(
      uri = "/some/new/uri",
      path = "/some/new/uri",
      method = "POST"
    )
  }

  private def route(request: RequestHeader): Option[Iteratee[Array[Byte], Result]] = {
    Play.global.onRouteRequest(request).collect {
      case action: EssentialAction => Play.global.doFilter(action)(request)
    }
  }

}

Ok, so you want to supply a new body? If you don't want to supply a new body, then the easiest way is to do it in onRouteRequest. But if you want to supply a new body, you could do this in onRouteRequest too, but as a filter, you should use EssentialFilter:

object RedirectFilter extends EssentialFilter {
  def apply(next: EssentialAction) = new EssentialAction {
    def apply(rh: RequestHeader) = {
      getRedirectParams(rh).flatMap { case (newRequest, body) =>
        route(newRequest).map { iteratee =>
          // Ignore the actual body - or you could consume it and transform it somehow.
          Iteratee.ignore[Array[Byte]].mapM { _ =>
            // Feed in the new body to the new action
            Enumerator(body) |>>> iteratee
          }
        }
      } getOrElse {
        next(request)
      }
    }
  }

  // Other methods go here, and like Guillaume pointed out, make sure you tag it
}