Basic Live-Harness endpoint functionality (#28438)

Co-authored-by: Jonathon Herbert <[email protected]>
Co-authored-by: Frederick O'Brien <[email protected]>

Author: 3 people

applications/app/controllers/InteractiveController.scala

@@ -73,6 +73,11 @@ class InteractiveController(
     capiLookup.lookup(path, range = Some(ArticleBlocks))
   }
 
+  def modelAndRenderHtml(response: ItemResponse)(
+      modifier: BlocksOn[InteractivePage] => BlocksOn[InteractivePage] = identity,
+  )(implicit req: RequestHeader): Future[Result] =
+    modelAndRender(response)(pageBlocks => renderHtml(modifier(pageBlocks)))
+
   def modelAndRender(
       response: ItemResponse,
   )(render: BlocksOn[InteractivePage] => Future[Result])(implicit req: RequestHeader): Future[Result] = {

common/app/model/meta/BlocksOn.scala

@@ -8,4 +8,6 @@ import com.gu.contentapi.client.model.v1.Blocks
   *
   * https://docondev.com/blog/2020/6/2/refactoring-introduce-parameter-object
   */
-case class BlocksOn[+P](page: P, blocks: Blocks)
+case class BlocksOn[+P](page: P, blocks: Blocks) {
+  def mapBoth[Q >: P](p: P => Q, b: Blocks => Blocks) = BlocksOn(p(page), b(blocks))
+}

preview/app/controllers/LiveHarnessController.scala

@@ -1,10 +1,63 @@
 package controllers
 
-import play.api.mvc.{Action, AnyContent, BaseController, ControllerComponents}
+import com.gu.contentapi.client.model.v1.ContentType
+import common.{GuLogging, ImplicitControllerExecutionContext}
+import contentapi.ContentApiClient
+import model.{ApplicationContext, ArticleBlocks, GenericFallback}
+import play.api.libs.json.{JsError, JsSuccess, JsValue}
+import play.api.libs.ws.WSClient
+import play.api.mvc.{Action, BaseController, ControllerComponents}
+import renderers.DotcomRenderingService
+import services.{CAPILookup, NewsletterService}
+import utils.LiveHarness.inject
+import utils.LiveHarnessInteractiveAtom
+
 import scala.concurrent.Future
 
-class LiveHarnessController(val controllerComponents: ControllerComponents) extends BaseController {
-  def renderLiveHarness(path: String): Action[AnyContent] = Action.async { implicit request =>
-    Future.successful(Ok("Hello, world!"))
+class LiveHarnessController(
+    contentApiClient: ContentApiClient,
+    val controllerComponents: ControllerComponents,
+    ws: WSClient,
+    newsletterService: NewsletterService,
+)(implicit val context: ApplicationContext)
+    extends BaseController
+    with GuLogging
+    with ImplicitControllerExecutionContext {
+
+  private val renderingService = DotcomRenderingService()
+
+  private val capiLookup: CAPILookup = new CAPILookup(contentApiClient)
+
+  private val articleController =
+    new ArticleController(
+      contentApiClient,
+      controllerComponents,
+      ws,
+      renderingService,
+      newsletterService,
+    )
+
+  private val interactiveController =
+    new InteractiveController(
+      contentApiClient,
+      ws,
+      controllerComponents,
+      renderingService,
+    )
+
+  def renderLiveHarness(path: String): Action[JsValue] = Action.async(parse.json) { implicit request =>
+    request.body.validate[List[LiveHarnessInteractiveAtom]] match {
+      case JsSuccess(atoms, _) =>
+        capiLookup.lookup(path, Some(ArticleBlocks)).flatMap { response =>
+          response.content
+            .map(_.`type`)
+            .collect {
+              case ContentType.Article     => articleController.mapAndRender(path, GenericFallback)(inject(atoms))
+              case ContentType.Interactive => interactiveController.modelAndRenderHtml(response)(inject(atoms))
+            }
+            .getOrElse(Future(BadRequest))
+        }
+      case JsError(errors) => Future(BadRequest(errors.toString()))
+    }
   }
 }

preview/app/utils/LiveHarness.scala

@@ -0,0 +1,68 @@
+package utils
+
+import com.gu.contentapi.client.model.v1.{BlockElement, ContentAtomElementFields, ElementType}
+import model.content.InteractiveAtom
+import model.meta.BlocksOn
+import model.{ArticlePage, Content, ContentPage, InteractivePage}
+import play.api.libs.json.{Json, Reads}
+
+case class LiveHarnessInteractiveAtom(
+    id: String,
+    title: String,
+    css: String,
+    html: String,
+    js: String,
+    weighting: String,
+) {
+  val atom = InteractiveAtom(
+    id = id,
+    `type` = "interactive",
+    title = title,
+    css = css,
+    html = html,
+    mainJS = Some(js),
+    docData = None,
+    placeholderUrl = None,
+  )
+
+  val blockElement = BlockElement(
+    `type` = ElementType.Contentatom,
+    assets = Seq.empty,
+    contentAtomTypeData = Some(
+      ContentAtomElementFields(
+        atomId = id,
+        atomType = "interactive",
+        role = Some(weighting),
+        isMandatory = None,
+      ),
+    ),
+  )
+}
+
+object LiveHarnessInteractiveAtom {
+  implicit val reads: Reads[LiveHarnessInteractiveAtom] = Json.reads
+}
+
+object LiveHarness {
+
+  trait PageUpdater[P <: ContentPage] { def update(page: P, content: Content): P }
+
+  implicit val iu: PageUpdater[InteractivePage] = (ip, nc) => ip.copy(interactive = ip.item.copy(content = nc))
+  implicit val au: PageUpdater[ArticlePage] = (ap, nc) => ap.copy(article = ap.item.copy(content = nc))
+
+  def inject[P <: ContentPage](harnessAtoms: Seq[LiveHarnessInteractiveAtom])(implicit
+      updater: PageUpdater[P],
+  ): BlocksOn[P] => BlocksOn[P] = _.mapBoth(
+    page => {
+      val content = page.item.content
+      updater.update(page, content.copy(atoms = content.atoms.map(_.copy(interactives = harnessAtoms.map(_.atom)))))
+    },
+    blocks =>
+      blocks.copy(body = blocks.body.map { bodyBlocks =>
+        val (headBlockOpt, tailBlocks) = bodyBlocks.splitAt(1)
+        headBlockOpt.map { headBlock =>
+          headBlock.copy(elements = harnessAtoms.map(_.blockElement) ++ headBlock.elements)
+        } ++ tailBlocks
+      }),
+  )
+}

preview/conf/routes

@@ -193,7 +193,7 @@ GET     /*path/email.emailjson      controllers.ArticleController.renderEmail(pa
 GET     /*path/email.emailtxt       controllers.ArticleController.renderEmail(path)
 
 # Harnesses
-POST    /desktop-auth/*path         controllers.LiveHarnessController.renderLiveHarness(path)
+POST    /desktop-auth/render-harness/*path         controllers.LiveHarnessController.renderLiveHarness(path)
 
 # Don't forward requests for favicon.ico to the Content API
 GET        /favicon.ico                                                                        controllers.FaviconController.favicon