Crossword picker and JSON route

applications/app/controllers/CrosswordsController.scala

@@ -1,13 +1,14 @@
 package controllers
 
 import com.gu.contentapi.client.model.v1.{Crossword, ItemResponse, Content => ApiContent, Section => ApiSection}
-import common.{Edition, ImplicitControllerExecutionContext, GuLogging}
+import common.{Edition, GuLogging, ImplicitControllerExecutionContext}
 import conf.Static
 import contentapi.ContentApiClient
 import pages.{CrosswordHtmlPage, IndexHtmlPage, PrintableCrosswordHtmlPage}
 import crosswords.{
   AccessibleCrosswordPage,
   AccessibleCrosswordRows,
+  CrosswordPageWithContent,
   CrosswordPageWithSvg,
   CrosswordSearchPageNoResult,
   CrosswordSearchPageWithResults,
@@ -21,6 +22,10 @@ import play.api.data._
 import play.api.mvc.{Action, RequestHeader, Result, _}
 import services.{IndexPage, IndexPageItem}
 import html.HtmlPageHelpers.ContentCSSFile
+import model.dotcomrendering.{DotcomRenderingDataModel, PageType}
+import play.api.libs.ws.WSClient
+import renderers.DotcomRenderingService
+import services.dotcomrendering.{CrosswordsPicker, RemoteRender}
 
 import scala.concurrent.Future
 import scala.concurrent.duration._
@@ -29,6 +34,9 @@ trait CrosswordController extends BaseController with GuLogging with ImplicitCon
 
   def contentApiClient: ContentApiClient
 
+  val remoteRenderer: DotcomRenderingService = DotcomRenderingService()
+  val wsClient: WSClient
+
   def noResults()(implicit request: RequestHeader): Result
 
   def getCrossword(crosswordType: String, id: Int)(implicit request: RequestHeader): Future[ItemResponse] = {
@@ -38,14 +46,14 @@ trait CrosswordController extends BaseController with GuLogging with ImplicitCon
   }
 
   def withCrossword(crosswordType: String, id: Int)(
-      f: (Crossword, ApiContent) => Result,
+      f: (Crossword, ApiContent) => Future[Result],
   )(implicit request: RequestHeader): Future[Result] = {
-    getCrossword(crosswordType, id).map { response =>
+    getCrossword(crosswordType, id).flatMap { response =>
       val maybeCrossword = for {
         content <- response.content
         crossword <- content.crossword
       } yield f(crossword, content)
-      maybeCrossword getOrElse noResults()
+      maybeCrossword getOrElse Future.successful(noResults())
     } recover {
       case t: Throwable =>
         log.error(s"Error retrieving $crosswordType crossword id $id from API", t)
@@ -58,22 +66,31 @@ trait CrosswordController extends BaseController with GuLogging with ImplicitCon
       context: ApplicationContext,
   ): Future[Result] = {
     withCrossword(crosswordType, id) { (crossword, content) =>
-      Cached(60.seconds)(
-        RevalidatableResult.Ok(
-          CrosswordHtmlPage.html(
-            CrosswordPageWithSvg(
-              CrosswordContent.make(CrosswordData.fromCrossword(crossword, content), content),
-              CrosswordSvg(crossword, None, None, false),
+      val page = CrosswordPageWithSvg(
+        CrosswordContent.make(CrosswordData.fromCrossword(crossword, content), content),
+        CrosswordSvg(crossword, None, None, false),
+      )
+
+      if (CrosswordsPicker.getTier(page) == RemoteRender)
+        remoteRenderer.getCrossword(wsClient, page, PageType(page, request, context))
+      else
+        Future.successful(
+          Cached(60.seconds)(
+            RevalidatableResult.Ok(
+              CrosswordHtmlPage.html(page),
             ),
           ),
-        ),
-      )
+        )
     }
   }
 }
 
-class CrosswordPageController(val contentApiClient: ContentApiClient, val controllerComponents: ControllerComponents)(
-    implicit context: ApplicationContext,
+class CrosswordPageController(
+    val contentApiClient: ContentApiClient,
+    val controllerComponents: ControllerComponents,
+    val wsClient: WSClient,
+)(implicit
+    context: ApplicationContext,
 ) extends CrosswordController {
 
   def noResults()(implicit request: RequestHeader): Result =
@@ -84,19 +101,41 @@ class CrosswordPageController(val contentApiClient: ContentApiClient, val contro
       renderCrosswordPage(crosswordType, id)
     }
 
+  def renderJson(crosswordType: String, id: Int): Action[AnyContent] = {
+    Action.async { implicit request =>
+      withCrossword(crosswordType, id) { (crossword, content) =>
+        val crosswordContent = CrosswordContent.make(CrosswordData.fromCrossword(crossword, content), content)
+        val crosswordPage = new CrosswordPageWithContent(crosswordContent)
+
+        val pageType = PageType(crosswordPage, request, context)
+        Future.successful(
+          common.renderJson(getDCRJson(crosswordPage, pageType), crosswordPage).as("application/json"),
+        )
+      }
+    }
+  }
+  private def getDCRJson(crosswordPage: CrosswordPageWithContent, pageType: PageType)(implicit
+      request: RequestHeader,
+  ): String =
+    DotcomRenderingDataModel.toJson(
+      DotcomRenderingDataModel.forCrossword(crosswordPage, request, pageType),
+    )
+
   def accessibleCrossword(crosswordType: String, id: Int): Action[AnyContent] =
     Action.async { implicit request =>
       withCrossword(crosswordType, id) { (crossword, content) =>
-        Cached(60.seconds)(
-          RevalidatableResult.Ok(
-            CrosswordHtmlPage.html(
-              AccessibleCrosswordPage(
-                CrosswordContent.make(
-                  CrosswordData
-                    .fromCrossword(crossword.copy(name = s"Accessible version of ${crossword.name}"), content),
-                  content,
+        Future.successful(
+          Cached(60.seconds)(
+            RevalidatableResult.Ok(
+              CrosswordHtmlPage.html(
+                AccessibleCrosswordPage(
+                  CrosswordContent.make(
+                    CrosswordData
+                      .fromCrossword(crossword.copy(name = s"Accessible version of ${crossword.name}"), content),
+                    content,
+                  ),
+                  AccessibleCrosswordRows(crossword),
                 ),
-                AccessibleCrosswordRows(crossword),
               ),
             ),
           ),
@@ -107,12 +146,14 @@ class CrosswordPageController(val contentApiClient: ContentApiClient, val contro
   def printableCrossword(crosswordType: String, id: Int): Action[AnyContent] =
     Action.async { implicit request =>
       withCrossword(crosswordType, id) { (crossword, content) =>
-        Cached(60.seconds)(
-          RevalidatableResult.Ok(
-            PrintableCrosswordHtmlPage.html(
-              CrosswordPageWithSvg(
-                CrosswordContent.make(CrosswordData.fromCrossword(crossword, content), content),
-                CrosswordSvg(crossword, None, None, false),
+        Future.successful(
+          Cached(60.seconds)(
+            RevalidatableResult.Ok(
+              PrintableCrosswordHtmlPage.html(
+                CrosswordPageWithSvg(
+                  CrosswordContent.make(CrosswordData.fromCrossword(crossword, content), content),
+                  CrosswordSvg(crossword, None, None, false),
+                ),
               ),
             ),
           ),
@@ -127,22 +168,25 @@ class CrosswordPageController(val contentApiClient: ContentApiClient, val contro
 
         val globalStylesheet = Static(s"stylesheets/$ContentCSSFile.css")
 
-        Cached(60.seconds) {
-          val body = s"""$xml"""
-          RevalidatableResult(
-            Cors {
-              Ok(body).as("image/svg+xml")
-            },
-            body,
-          )
-        }
+        Future.successful(
+          Cached(60.seconds) {
+            val body = s"""$xml"""
+            RevalidatableResult(
+              Cors {
+                Ok(body).as("image/svg+xml")
+              },
+              body,
+            )
+          },
+        )
       }
     }
 }
 
 class CrosswordSearchController(
     val contentApiClient: ContentApiClient,
     val controllerComponents: ControllerComponents,
+    val wsClient: WSClient,
 )(implicit context: ApplicationContext)
     extends CrosswordController {
   val searchForm = Form(

applications/app/services/dotcomrendering/CrosswordsPicker.scala

@@ -0,0 +1,51 @@
+package services.dotcomrendering
+
+import common.GuLogging
+import crosswords.CrosswordPageWithContent
+import model.Cors.RichRequestHeader
+import play.api.mvc.RequestHeader
+import utils.DotcomponentsLogger
+
+object CrosswordsPicker extends GuLogging {
+
+  /**
+    *
+    * Add to this function any logic for including/excluding
+    * a crossword page from being rendered with DCR
+    *
+    * Currently defaulting to false until we implement crosswords in DCR
+    *
+    * */
+  private def dcrCouldRender(crosswordPageWithContent: CrosswordPageWithContent): Boolean = {
+    false
+  }
+
+  def getTier(
+      crosswordPageWithContent: CrosswordPageWithContent,
+  )(implicit
+      request: RequestHeader,
+  ): RenderType = {
+
+    val participatingInTest = false // until we create a test for this content type
+    val dcrCanRender = dcrCouldRender(crosswordPageWithContent)
+
+    val tier = {
+      if (request.forceDCROff) LocalRender
+      else if (request.forceDCR) RemoteRender
+      else if (dcrCanRender && participatingInTest) RemoteRender
+      else LocalRender
+    }
+
+    if (tier == RemoteRender) {
+      DotcomponentsLogger.logger.logRequest(
+        s"path executing in dotcomponents",
+        Map.empty,
+        crosswordPageWithContent.item,
+      )
+    } else {
+      DotcomponentsLogger.logger.logRequest(s"path executing in web", Map.empty, crosswordPageWithContent.item)
+    }
+
+    tier
+  }
+}

applications/conf/routes

@@ -18,6 +18,7 @@ GET        /survey/thankyou
 
 # NOTE: Leave this as it is, otherwise we don't render /crosswords/series/prize, for example.
 GET        /crosswords/$crosswordType<cryptic|quick|quiptic|prize|everyman|azed|special|genius|speedy|weekend>/:id.svg       controllers.CrosswordPageController.thumbnail(crosswordType: String, id: Int)
+GET        /crosswords/$crosswordType<cryptic|quick|quiptic|prize|everyman|azed|special|genius|speedy|weekend>/:id.json      controllers.CrosswordPageController.renderJson(crosswordType: String, id: Int)
 GET        /crosswords/$crosswordType<cryptic|quick|quiptic|prize|everyman|azed|special|genius|speedy|weekend>/:id           controllers.CrosswordPageController.crossword(crosswordType: String, id: Int)
 GET        /crosswords/$crosswordType<cryptic|quick|quiptic|prize|everyman|special|genius|speedy|weekend>/:id/print          controllers.CrosswordPageController.printableCrossword(crosswordType: String, id: Int)
 GET        /crosswords/accessible/$crosswordType<cryptic|quick|quiptic|prize|everyman|azed|special|genius|speedy|weekend>/:id     controllers.CrosswordPageController.accessibleCrossword(crosswordType: String, id: Int)

applications/test/CrosswordDataTest.scala

@@ -23,7 +23,7 @@ import org.scalatest.time.{Millis, Span}
   "CrosswordData" - {
 
     lazy val crosswordPageController =
-      new CrosswordPageController(testContentApiClient, play.api.test.Helpers.stubControllerComponents())
+      new CrosswordPageController(testContentApiClient, play.api.test.Helpers.stubControllerComponents(), wsClient)
 
     "fromCrossword should normalize separators for grouped entries" in {
 

applications/test/CrosswordPageMetaDataTest.scala

@@ -18,7 +18,7 @@ import org.scalatest.{BeforeAndAfterAll, DoNotDiscover}
 
   val crosswordUrl = "crosswords/cryptic/26697"
   lazy val crosswordPageController =
-    new CrosswordPageController(testContentApiClient, play.api.test.Helpers.stubControllerComponents())
+    new CrosswordPageController(testContentApiClient, play.api.test.Helpers.stubControllerComponents(), wsClient)
 
   it should "not include the ios deep link" in {
     val result = crosswordPageController.crossword("cryptic", 26697)(TestRequest(crosswordUrl))

applications/app/crosswords/AccessibleCrosswordRows.scala → common/app/crosswords/AccessibleCrosswordRows.scala

@@ -1,6 +1,6 @@
 package crosswords
 
-import com.gu.contentapi.client.model.v1.{CrosswordDimensions, Crossword}
+import com.gu.contentapi.client.model.v1.{Crossword, CrosswordDimensions}
 import model.CrosswordPosition
 
 case class AccessibleCrosswordRow(rowNumber: Int, blankColumns: List[Char])

applications/app/crosswords/CrosswordPage.scala → common/app/crosswords/CrosswordPage.scala

@@ -1,8 +1,9 @@
 package crosswords
 
+import crosswords.CrosswordSvg.{BorderSize, CellSize}
 import model._
-import java.time.LocalDateTime
 
+import java.time.LocalDateTime
 import scala.xml.Elem
 
 sealed trait CrosswordPage extends Page
@@ -27,8 +28,6 @@ class CrosswordPageWithContent(content: CrosswordContent) extends ContentPage {
   override lazy val item = content
   val crossword = content.crossword
 
-  import crosswords.CrosswordSvg.{BorderSize, CellSize}
-
   case class SvgDimensions(width: Int, height: Int) {
     def styleString: String = s"width: $width; height: $height"
   }

common/app/model/dotcomrendering/DotcomRenderingDataModel.scala

@@ -7,6 +7,7 @@ import common.Maps.RichMap
 import common.commercial.EditionCommercialProperties
 import common.{CanonicalLink, Chronos, Edition, Localisation, RichRequestHeader}
 import conf.Configuration
+import crosswords.CrosswordPageWithContent
 import experiments.ActiveExperiments
 import model.dotcomrendering.DotcomRenderingUtils._
 import model.dotcomrendering.pageElements.{PageElement, TextCleaner}
@@ -16,6 +17,7 @@ import model.{
   CanonicalLiveBlog,
   ContentFormat,
   ContentPage,
+  CrosswordData,
   GUDateTimeFormatNew,
   GalleryPage,
   ImageContentPage,
@@ -108,6 +110,7 @@ case class DotcomRenderingDataModel(
     showTableOfContents: Boolean,
     lang: Option[String],
     isRightToLeftLang: Boolean,
+    crossword: Option[CrosswordData],
 )
 
 object DotcomRenderingDataModel {
@@ -187,6 +190,7 @@ object DotcomRenderingDataModel {
         "showTableOfContents" -> model.showTableOfContents,
         "lang" -> model.lang,
         "isRightToLeftLang" -> model.isRightToLeftLang,
+        "crossword" -> model.crossword,
       )
 
       ElementsEnhancer.enhanceDcrObject(obj)
@@ -338,6 +342,28 @@ object DotcomRenderingDataModel {
     )
   }
 
+  def forCrossword(
+      crosswordPage: CrosswordPageWithContent,
+      request: RequestHeader,
+      pageType: PageType,
+  ): DotcomRenderingDataModel = {
+    val linkedData = LinkedData.forArticle(
+      article = crosswordPage.item,
+      baseURL = Configuration.dotcom.baseUrl,
+      fallbackLogo = Configuration.images.fallbackLogo,
+    )
+
+    apply(
+      page = crosswordPage,
+      request = request,
+      pageType = pageType,
+      linkedData = linkedData,
+      mainBlock = None,
+      bodyBlocks = Seq.empty,
+      crossword = Some(crosswordPage.crossword),
+    )
+  }
+
   def keyEventsFallback(
       blocks: APIBlocks,
   ): Seq[APIBlock] = {
@@ -442,6 +468,7 @@ object DotcomRenderingDataModel {
       filterKeyEvents: Boolean = false,
       mostRecentBlockId: Option[String] = None,
       forceLive: Boolean = false,
+      crossword: Option[CrosswordData] = None,
   ): DotcomRenderingDataModel = {
 
     val edition = Edition.edition(request)
@@ -635,6 +662,7 @@ object DotcomRenderingDataModel {
       showTableOfContents = content.fields.showTableOfContents.getOrElse(false),
       lang = content.fields.lang,
       isRightToLeftLang = content.fields.isRightToLeftLang,
+      crossword = crossword,
     )
   }
 }