How to handle implicitly passed futures in play views - scala

Question

In my particular case I have a menu that is rendered on all pages. The menu content is loaded from a database using slick and passed implicitly to the view. The whole thing looks like this:
Controller
class Application #Inject()(
implicit val menuContext: MenuContext
) extends Controller {
def index = Action.async {
val content: Future[Content] = getContent
content.map(c => Ok(views.html.index(c)))
}
}
MenuContext
class MenuContext {
val models: Future[List[SomeModel]] = getModelsFromDB
}
View
#(content: Content)(implicit menuContext: MenuContext)
...
#menuContext.models // how to access my actual model and not the Future?
...
How do I access List[SomeModel] in my view? Is there an Action.async equivalent in play for passing implicit parameters? Or is there maybe even a better solution for stuff that is required in (almost) all views?

Answer 1

Definitely not a good idea to make a template have to deal with a Future - so the question becomes the one in your comment - how to non-blockingly (?) get the content from your async content source, as well as your menu items from your other async content source?
A for-comprehension on the two Future instances does the trick:
def index = Action.async {
val fContent:Future[Content] = getContent
val fMenus:Future[List[SomeModel] = getModelsFromDB
for {
content <- fContent
menus <- fMenus
} yield(Ok(views.html.index(content)(menus))))
}
Note: You may be tempted to try and save a few lines and put the method calls (getContent, getModelsFromDB) straight into the for block.
Unfortunately, while it'll compile and work, the two tasks won't run in parallel, thereby making the exercise somewhat futile.

Answer 2

OK I'm adding another answer here, to specifically try to DRY up the injection of menus into your Actions.
The principal problem is that you need to inject the menus at just the right time, namely:
When you have the data ready (or at least a Future holding the data)
When you know which template is going to be rendered
When you know what status code you'll be returning
Because of these constraints, we can't use an ActionBuilder or ActionRefiner - they assume that your inner block of controller code will produce a finished Result.
So instead, we'll define a trait we can mix into our controllers:
trait MenuDecoration {
def withMenuSimple(body: Future[List[SomeModel] => Result]):Future[Result] = {
val fm = getModelsFromDB
val fb = body
for {
m <- fm
b <- fb
} yield(b(m))
}
}
This should look pretty familiar from my other answer, and it works the same way - it will start the execution of both async tasks, bringing them together once they are both done.
An Action that needs to decorate the template with a menu looks like this:
class BlahController extends Controller with MenuDecoration {
def index = Action.async {
withMenuSimple {
getContent.map { content => implicit menu =>
Ok(views.html.index(content))
}
}
}
}
Why withMenuSimple ? Because at some point you'll probably want to examine the Request - so we have this alternative:
trait MenuDecoration {
...
def withMenu(body: RequestHeader => Future[List[SomeModel] => Result])(implicit request:RequestHeader):Future[Result] = {
val fm = fMenus
val fb = body(request)
for {
m <- fm
b <- fb
} yield(b(m))
}
}
which you'd use like this:
def indexWithReq = Action.async { implicit request =>
withMenu { req =>
getContent.map { content => implicit menu =>
Ok(views.html.index(content))
}
}
}