Performance improvements.

Author: jrouly

build.sbt

@@ -13,7 +13,7 @@ lazy val commonSettings = Seq(
   resolvers += Resolver.bintrayRepo("jrouly", "sbt-release"),
   organization := "net.rouly",
   scalaVersion := "2.11.12",
-  version := "1.1",
+  version := "1.2",
   name := s"employability-${name.value}"
 ) ++ Bintray.settings
 

web/app/net/rouly/employability/web/api/ApiController.scala

@@ -1,32 +1,38 @@
 package net.rouly.employability.web.api
 
+import net.rouly.common.server.play.implicits.ResultBodyImplicits._
 import net.rouly.employability.models.Topic
 import net.rouly.employability.web.elasticsearch.{DocumentService, TopicService}
 import play.api.libs.json.{Format, Json}
 import play.api.mvc.{AbstractController, ControllerComponents}
 
+import scala.concurrent.ExecutionContext
+
 class ApiController(
   cc: ControllerComponents,
   documentService: DocumentService,
   topicService: TopicService
-) extends AbstractController(cc) {
+)(implicit ec: ExecutionContext)
+  extends AbstractController(cc) {
 
   def allTopics = {
     Action(topicService.topicSource.chunkedResponse)
   }
 
   def topicById(id: String) = {
-    Action {
+    Action.async {
       topicService
-        .topicSource
-        .filter(_.id == id)
-        .take(1)
-        .chunkedResponse
+        .topicById(id)
+        .toJsonResult
     }
   }
 
   def docsByTopicId(id: String) = {
-    Action(documentService.documentsByTopic(id).chunkedResponse)
+    Action.async {
+      documentService
+        .documentById(id)
+        .toJsonResult
+    }
   }
 
 }

web/app/net/rouly/employability/web/application/ElasticsearchController.scala

@@ -39,20 +39,21 @@ class ElasticsearchController(
 
   def allTopics = {
     Action.async {
-      for {
-        topics <- topicService.topicSource.runWith(Sink.collection)
-      } yield Ok(application.topics(topics.toList.sortBy(_.id.toInt))).cached
+      topicService
+        .topicSource
+        .runWith(Sink.collection)
+        .map(_.toList.sortBy(_.id.toInt))
+        .as(application.topics.apply)
+        .cached
     }
   }
 
   def topicById(id: String) = {
     Action.async {
       for {
-        topic <- topicService.topicSource.filter(_.id == id).runWith(Sink.headOption)
+        topic <- topicService.topicById(id)
         docs <- documentService.documentsByTopic(id).take(10).runWith(Sink.collection)
-      } yield {
-        topic.render(application.topic(_, docs.toList)).cached
-      }
+      } yield Ok(application.topic(topic, docs.toList)).cached
     }
   }
 
@@ -67,9 +68,10 @@ class ElasticsearchController(
 
   def docById(id: String) = {
     Action.async {
-      for {
-        doc <- documentService.documentSource.filter(_.id == id).runWith(Sink.headOption)
-      } yield doc.render(application.document.apply).cached
+      documentService
+        .documentById(id)
+        .as(application.document.apply)
+        .cached
     }
   }
 

web/app/net/rouly/employability/web/application/package.scala

@@ -3,18 +3,33 @@ package net.rouly.employability.web
 import play.api.mvc.{Result, Results}
 import play.twirl.api.Html
 
+import scala.concurrent.{ExecutionContext, Future}
+
 package object application {
 
-  implicit class OptionalRender[T](option: Option[T]) {
-    def render(r: T => Html): Result = option match {
+  implicit class RenderOption[T](option: Option[T]) {
+    def as(r: T => Html): Result = option match {
       case Some(t) => Results.Ok(r(t))
       case None => Results.NotFound
     }
   }
 
+  implicit class RenderT[T](t: T) {
+    def as(r: T => Html): Result = Results.Ok(r(t))
+  }
+
+  implicit class RenderFutureT[T](ft: Future[T]) {
+    def as(r: T => Html)(implicit ec: ExecutionContext): Future[Result] = ft.map(t => Results.Ok(r(t)))
+  }
+
   implicit class RichResult(result: Result) {
     def cached: Result = result.withHeaders("Cache-Control" -> "public")
     def notCached: Result = result.withHeaders("Cache-Control" -> "no-store")
   }
 
+  implicit class RichFutureResult(fresult: Future[Result]) {
+    def cached(implicit ec: ExecutionContext): Future[Result] = fresult.map(_.withHeaders("Cache-Control" -> "public"))
+    def notCached(implicit ec: ExecutionContext): Future[Result] = fresult.map(_.withHeaders("Cache-Control" -> "no-store"))
+  }
+
 }

web/app/net/rouly/employability/web/elasticsearch/DocumentService.scala

@@ -26,6 +26,12 @@ class DocumentService(elasticsearch: ElasticsearchModule)(implicit ec: Execution
       .map(_.to[ModeledDocument])
   }
 
+  def documentById(docId: String): Future[ModeledDocument] = {
+    execute {
+      get(docId).from(elasticsearch.config.modeledDocumentIndex)
+    }.map(_.result.to[ModeledDocument])
+  }
+
   def documentsByTopic(topicId: String): Source[ModeledDocument, NotUsed] = {
     val weightQuery = rangeQuery("weightedTopics.weight").gt(0.1)
     val topicIdQuery = termQuery("weightedTopics.topic.id", topicId)

web/app/net/rouly/employability/web/elasticsearch/TopicService.scala

@@ -25,4 +25,10 @@ class TopicService(elasticsearch: ElasticsearchModule)(implicit ec: ExecutionCon
       .map(_.to[Topic])
   }
 
+  def topicById(topicId: String): Future[Topic] = {
+    execute {
+      get(topicId).from(elasticsearch.config.topicIndex)
+    }.map(_.result.to[Topic])
+  }
+
 }