DCR flag and picker for Image Content

applications/app/controllers/ImageContentController.scala

@@ -1,7 +1,7 @@
 package controllers
 
 import com.gu.contentapi.client.model.{Direction, FollowingSearchQuery, SearchQuery}
-import com.gu.contentapi.client.model.v1.{ItemResponse, Content => ApiContent}
+import com.gu.contentapi.client.model.v1.{Block, ItemResponse, Content => ApiContent}
 import common._
 import conf.switches.Switches
 import contentapi.ContentApiClient
@@ -13,17 +13,17 @@ import services.ImageQuery
 import views.support.RenderOtherStatus
 import play.api.libs.json._
 import conf.Configuration.contentApi
+import model.dotcomrendering.{DotcomRenderingDataModel, PageType}
+import renderers.DotcomRenderingService
+import services.dotcomrendering.{ImageContentPicker, RemoteRender}
 
 import scala.concurrent.Future
 
-case class ImageContentPage(image: ImageContent, related: RelatedContent) extends ContentPage {
-  override lazy val item: ImageContent = image
-}
-
 class ImageContentController(
     val contentApiClient: ContentApiClient,
     val controllerComponents: ControllerComponents,
     wsClient: WSClient,
+    remoteRenderer: renderers.DotcomRenderingService = DotcomRenderingService(),
 )(implicit context: ApplicationContext)
     extends BaseController
     with RendersItemResponse
@@ -42,11 +42,42 @@ class ImageContentController(
   }
 
   override def renderItem(path: String)(implicit request: RequestHeader): Future[Result] =
-    image(Edition(request), path).map {
-      case Right(content) => renderImageContent(content)
-      case Left(result)   => RenderOtherStatus(result)
+    image(Edition(request), path).flatMap {
+      case Right((content, mainBlock)) =>
+        val tier = ImageContentPicker.getTier(content)
+
+        tier match {
+          case RemoteRender => remoteRender(content, mainBlock)
+          case _            => Future.successful(renderImageContent(content))
+        }
+      case Left(result) => Future.successful(RenderOtherStatus(result))
     }
 
+  private def getDCRJson(content: ImageContentPage, pageType: PageType, mainBlock: Option[Block])(implicit
+      request: RequestHeader,
+  ): String = {
+    DotcomRenderingDataModel.toJson(DotcomRenderingDataModel.forImageContent(content, request, pageType, mainBlock))
+  }
+
+  private def remoteRender(content: ImageContentPage, mainBlock: Option[Block])(implicit
+      request: RequestHeader,
+  ): Future[Result] = {
+    val pageType = PageType(content, request, context)
+
+    if (request.isJson) {
+      Future.successful(
+        common.renderJson(getDCRJson(content, pageType, mainBlock), content).as("application/json"),
+      )
+    } else {
+      remoteRenderer.getImageContent(
+        wsClient,
+        content,
+        pageType,
+        mainBlock,
+      )
+    }
+  }
+
   private def isSupported(c: ApiContent) = c.isImageContent
   override def canRender(i: ItemResponse): Boolean = i.content.exists(isSupported)
 

applications/app/controllers/InteractiveController.scala

@@ -15,6 +15,7 @@ import pages.InteractiveHtmlPage
 import play.api.libs.ws.WSClient
 import play.api.mvc._
 import renderers.DotcomRenderingService
+import services.dotcomrendering.{DotcomRendering, InteractivePicker, PressedInteractive}
 import services.{CAPILookup, USElection2020AmpPages, _}
 
 import scala.concurrent.Future

applications/app/pages/ContentHtmlPage.scala

@@ -1,10 +1,10 @@
 package pages
 
 import common.Edition
-import controllers.{ImageContentPage, MediaPage, QuizAnswersPage, TodayNewspaper}
+import controllers.{MediaPage, QuizAnswersPage, TodayNewspaper}
 import html.HtmlPageHelpers._
 import html.{HtmlPage, Styles}
-import model.{ApplicationContext, Audio, Page}
+import model.{ApplicationContext, Audio, ImageContentPage, Page}
 import play.api.mvc.RequestHeader
 import play.twirl.api.Html
 import views.html.fragments._

applications/app/services/ImageQuery.scala

@@ -1,10 +1,9 @@
 package services
 
-import com.gu.contentapi.client.model.v1.ItemResponse
+import com.gu.contentapi.client.model.v1.{Block, Blocks, ItemResponse}
 import common.{Edition, _}
 import contentapi.ContentApiClient
-import controllers.ImageContentPage
-import model.{ApiContent2Is, ApplicationContext, Content, ImageContent, StoryPackages}
+import model.{ApiContent2Is, ApplicationContext, Content, ImageContent, ImageContentPage, StoryPackages}
 import play.api.mvc.{RequestHeader, Result => PlayResult}
 
 import scala.concurrent.Future
@@ -16,18 +15,24 @@ trait ImageQuery extends ConciergeRepository {
   def image(edition: Edition, path: String)(implicit
       request: RequestHeader,
       context: ApplicationContext,
-  ): Future[Either[PlayResult, ImageContentPage]] = {
+  ): Future[Either[PlayResult, (ImageContentPage, Option[Block])]] = {
     log.info(s"Fetching image content: $path for edition ${edition.id}")
     val response = contentApiClient.getResponse(
       contentApiClient
         .item(path, edition)
+        .showBlocks("main")
         .showFields("all"),
     ) map { response: ItemResponse =>
       val mainContent = response.content.filter(_.isImageContent).map(Content(_))
+      val mainBlock = response.content.flatMap(_.blocks).getOrElse(Blocks()).main
       mainContent
         .map {
-          case content: ImageContent => Right(ImageContentPage(content, StoryPackages(content.metadata.id, response)))
-          case _                     => Left(NotFound)
+          case content: ImageContent =>
+            Right(
+              ImageContentPage(content, StoryPackages(content.metadata.id, response)),
+              mainBlock,
+            )
+          case _ => Left(NotFound)
         }
         .getOrElse(Left(NotFound))
     }

applications/app/services/dotcomrendering/ImageContentPicker.scala

@@ -0,0 +1,48 @@
+package services.dotcomrendering
+
+import common.GuLogging
+import experiments.{ActiveExperiments, DCRImageContent}
+import model.Cors.RichRequestHeader
+import model.ImageContentPage
+import play.api.mvc.RequestHeader
+import utils.DotcomponentsLogger
+
+object ImageContentPicker extends GuLogging {
+
+  /**
+    *
+    * Add to this function any logic for including/excluding
+    * an image article from being rendered with DCR
+    *
+    * Currently defaulting to false until we implement image articles in DCR
+    *
+    * */
+  private def dcrCouldRender(imageContentPage: ImageContentPage): Boolean = {
+    false
+  }
+
+  def getTier(
+      imageContentPage: ImageContentPage,
+  )(implicit
+      request: RequestHeader,
+  ): RenderType = {
+
+    val participatingInTest = ActiveExperiments.isParticipating(DCRImageContent)
+    val dcrCanRender = dcrCouldRender(imageContentPage)
+
+    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, imageContentPage.image)
+    } else {
+      DotcomponentsLogger.logger.logRequest(s"path executing in web", Map.empty, imageContentPage.image)
+    }
+
+    tier
+  }
+}

applications/app/services/InteractivePicker.scala → applications/app/services/dotcomrendering/InteractivePicker.scala

@@ -1,9 +1,8 @@
-package services
+package services.dotcomrendering
 
 import conf.switches.Switches.InteractivePickerFeature
-import play.api.mvc.RequestHeader
 import implicits.Requests._
-import services.dotcomrendering.PressedContent
+import play.api.mvc.RequestHeader
 
 sealed trait RenderingTier
 object DotcomRendering extends RenderingTier

applications/app/services/dotcomrendering/RenderType.scala

@@ -0,0 +1,5 @@
+package services.dotcomrendering
+
+sealed trait RenderType
+case object RemoteRender extends RenderType
+case object LocalRender extends RenderType

applications/app/views/fragments/imageContentBody.scala.html

@@ -1,3 +1,4 @@
+@import model.ImageContentPage
 @(page: ImageContentPage)(implicit request: RequestHeader, context: model.ApplicationContext)
 @import layout.ContentWidths.ImageContentMedia
 @import views.support.Commercial._

applications/test/services/InteractivePickerTest.scala

@@ -4,6 +4,7 @@ import org.scalatest.DoNotDiscover
 import test.TestRequest
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
+import services.dotcomrendering.{DotcomRendering, FrontendLegacy, InteractivePicker, PressedInteractive}
 
 @DoNotDiscover class InteractivePickerTest extends AnyFlatSpec with Matchers {
   val path = "/lifeandstyle/ng-interactive/2016/mar/12/stephen-collins-cats-cartoon"

article/app/controllers/LiveBlogController.scala

@@ -17,9 +17,9 @@ import play.api.libs.ws.WSClient
 import play.api.mvc._
 import play.twirl.api.Html
 import renderers.DotcomRenderingService
-import services.dotcomrendering.DotcomponentsLogger
 import services.{CAPILookup, NewsletterService, MessageUsService}
 import topics.TopicService
+import utils.DotcomponentsLogger
 import views.support.RenderOtherStatus
 
 import scala.concurrent.Future
@@ -191,7 +191,7 @@ class LiveBlogController(
 
             if (remoteRendering) {
               DotcomponentsLogger.logger
-                .logRequest(s"liveblog executing in dotcomponents", properties, page)
+                .logRequest(s"liveblog executing in dotcomponents", properties, page.article)
               val pageType: PageType = PageType(blog, request, context)
               remoteRenderer.getArticle(
                 ws,
@@ -206,7 +206,7 @@ class LiveBlogController(
                 messageUs,
               )
             } else {
-              DotcomponentsLogger.logger.logRequest(s"liveblog executing in web", properties, page)
+              DotcomponentsLogger.logger.logRequest(s"liveblog executing in web", properties, page.article)
               Future.successful(common.renderHtml(LiveBlogHtmlPage.html(blog), blog))
             }
           case (blog: LiveBlogPage, AmpFormat) if isAmpSupported =>

article/app/services/dotcomrendering/ArticlePicker.scala

@@ -4,6 +4,7 @@ import com.madgag.scala.collection.decorators.MapDecorator
 import implicits.Requests._
 import model.{ArticlePage, PageWithStoryPackage}
 import play.api.mvc.RequestHeader
+import utils.DotcomponentsLogger
 
 object ArticlePageChecks {
 
@@ -69,11 +70,11 @@ object ArticlePicker {
       ("pageTones" -> pageTones)
 
     if (tier == RemoteRender) {
-      DotcomponentsLogger.logger.logRequest(s"path executing in dotcomponents", features, page)
+      DotcomponentsLogger.logger.logRequest(s"path executing in dotcomponents", features, page.article)
     } else if (tier == PressedArticle) {
-      DotcomponentsLogger.logger.logRequest(s"path executing from pressed content", features, page)
+      DotcomponentsLogger.logger.logRequest(s"path executing from pressed content", features, page.article)
     } else {
-      DotcomponentsLogger.logger.logRequest(s"path executing in web", features, page)
+      DotcomponentsLogger.logger.logRequest(s"path executing in web", features, page.article)
     }
 
     tier

common/app/experiments/Experiments.scala

@@ -40,6 +40,15 @@ object DCRFronts
       participationGroup = Perc50,
     )
 
+object DCRImageContent
+    extends Experiment(
+      name = "dcr-image-content",
+      description = "Use DCR for image content",
+      owners = Seq(Owner.withGithub("@guardian/dotcom-platform")),
+      sellByDate = LocalDate.of(2024, 1, 1),
+      participationGroup = Perc50,
+    )
+
 object OfferHttp3
     extends Experiment(
       name = "offer-http3",

common/app/model/ImageContentPage.scala

@@ -0,0 +1,5 @@
+package model
+
+case class ImageContentPage(image: ImageContent, related: RelatedContent) extends ContentPage {
+  override lazy val item: ImageContent = image
+}