Merge pull request #28208 from guardian/cc/product-element

Add product element 

Co-authored-by: Charley_Campbell <[email protected]>
Co-authored-by: Emma Imber <[email protected]>

Author: 3 people

common/app/conf/switches/FeatureSwitches.scala

@@ -638,4 +638,15 @@ trait FeatureSwitches {
     exposeClientSide = true,
     highImpact = false,
   )
+
+  val ProductLeftColCards = Switch(
+    SwitchGroup.Feature,
+    "product-left-col-cards",
+    "Enables product element summary cards to be shown in the left column at wide breakpoints",
+    owners = Seq(Owner.withEmail("[email protected]")),
+    sellByDate = never,
+    safeState = Off,
+    exposeClientSide = true,
+    highImpact = false,
+  )
 }

common/app/model/dotcomrendering/ElementsEnhancer.scala

@@ -19,6 +19,7 @@ object ElementsEnhancer {
         elementType match {
           case "model.dotcomrendering.pageElements.ListBlockElement"     => enhanceListBlockElement(elementWithId)
           case "model.dotcomrendering.pageElements.TimelineBlockElement" => enhanceTimelineBlockElement(elementWithId)
+          case "model.dotcomrendering.pageElements.ProductBlockElement"  => enhanceProductBlockElement(elementWithId)
           case _                                                         => elementWithId;
         }
       case _ => element
@@ -33,6 +34,10 @@ object ElementsEnhancer {
     elementWithId ++ Json.obj("items" -> listItemsWithIds)
   }
 
+  def enhanceProductBlockElement(elementWithId: JsObject): JsObject = {
+    elementWithId ++ Json.obj("content" -> enhanceElements(elementWithId.value("content")))
+  }
+
   def enhanceTimelineBlockElement(element: JsObject): JsObject = {
     val sectionsList = element.value("sections").as[List[JsObject]]
     val sectionsListWithIds = sectionsList.map { section =>

common/app/model/dotcomrendering/pageElements/PageElement.scala

@@ -6,6 +6,11 @@ import com.gu.contentapi.client.model.v1.EmbedTracksType.DoesNotTrack
 import com.gu.contentapi.client.model.v1.{
   EmbedTracking,
   LinkType,
+  ProductDisplayType,
+  ProductElementFields,
+  ProductCTA => ApiProductCta,
+  ProductCustomAttribute => ApiProductCustomAttribute,
+  ProductImage => ApiProductImage,
   SponsorshipType,
   TimelineElementFields,
   WitnessElementFields,
@@ -510,6 +515,48 @@ object LinkBlockElement {
   implicit val LinkBlockElementWrites: Writes[LinkBlockElement] = Json.writes[LinkBlockElement]
 }
 
+case class ProductImage(
+    url: String,
+    caption: String,
+    height: Int,
+    width: Int,
+    alt: String,
+    credit: String,
+    displayCredit: Boolean,
+)
+case class ProductCustomAttribute(
+    name: String,
+    value: String,
+)
+case class ProductCta(
+    text: String,
+    price: String,
+    retailer: String,
+    url: String,
+)
+case class ProductBlockElement(
+    productName: String,
+    brandName: String,
+    primaryHeadingHtml: String,
+    secondaryHeadingHtml: String,
+    starRating: String,
+    productCtas: List[ProductCta],
+    customAttributes: List[ProductCustomAttribute],
+    image: Option[ProductImage],
+    content: Seq[PageElement],
+    displayType: ProductDisplayType,
+) extends PageElement
+object ProductBlockElement {
+  implicit val ProductBlockElementImageWrites: Writes[ProductImage] = Json.writes[ProductImage]
+  implicit val ProductBlockElementCTAWrites: Writes[ProductCta] = Json.writes[ProductCta]
+  implicit val ProductBlockElementCustomAttributeWrites: Writes[ProductCustomAttribute] =
+    Json.writes[ProductCustomAttribute]
+  implicit val ProductBlockElementDisplayTypeWrites: Writes[ProductDisplayType] = Writes { displayType =>
+    JsString(displayType.name)
+  }
+  implicit val ProductBlockElementWrites: Writes[ProductBlockElement] = Json.writes[ProductBlockElement]
+}
+
 case class QABlockElement(id: String, title: String, img: Option[String], html: String, credit: String)
     extends PageElement
 object QABlockElement {
@@ -897,6 +944,7 @@ object PageElement {
       case _: ListBlockElement            => true
       case _: TimelineBlockElement        => true
       case _: LinkBlockElement            => true
+      case _: ProductBlockElement         => true
 
       // TODO we should quick fail here for these rather than pointlessly go to DCR
       case table: TableBlockElement if table.isMandatory.exists(identity) => true
@@ -1534,6 +1582,23 @@ object PageElement {
           )
         }.toList
 
+      case Product =>
+        element.productTypeData.map { productTypeData =>
+          makeProduct(
+            addAffiliateLinks,
+            pageUrl,
+            atoms,
+            isImmersive,
+            campaigns,
+            calloutsUrl,
+            edition,
+            webPublicationDate,
+            productTypeData,
+            isGallery,
+            isTheFilterUS,
+          )
+        }.toList
+
       case EnumUnknownElementType(f) => List(UnknownBlockElement(None))
       case _                         => Nil
     }
@@ -1643,6 +1708,112 @@ object PageElement {
     )
   }
 
+  private def makeProduct(
+      addAffiliateLinks: Boolean,
+      pageUrl: String,
+      atoms: Iterable[Atom],
+      isImmersive: Boolean,
+      campaigns: Option[JsValue],
+      calloutsUrl: Option[String],
+      edition: Edition,
+      webPublicationDate: DateTime,
+      product: ProductElementFields,
+      isGallery: Boolean,
+      isTheFilterUS: Boolean,
+  ) = {
+
+    def createProductCta(
+        cta: ApiProductCta,
+        pageUrl: String,
+        addAffiliateLinks: Boolean,
+        isTheFilterUS: Boolean,
+    ): Option[ProductCta] = {
+      for {
+        // URL must exist and be non-empty
+        url <- AffiliateLinksCleaner
+          .replaceUrlInLink(cta.url, pageUrl, addAffiliateLinks, isTheFilterUS)
+          .filter(_.nonEmpty)
+
+        // Must have either non-empty text, or both non-empty price & retailer
+        if cta.text.exists(_.nonEmpty) ||
+          (cta.price.exists(_.nonEmpty) && cta.retailer.exists(_.nonEmpty))
+      } yield ProductCta(
+        text = cta.text.getOrElse(""),
+        price = cta.price.getOrElse(""),
+        retailer = cta.retailer.getOrElse(""),
+        url = url,
+      )
+    }
+
+    def createProductCustomAttribute(apiCustomAttribute: ApiProductCustomAttribute): Option[ProductCustomAttribute] = {
+      for {
+        name <- apiCustomAttribute.name if name.nonEmpty
+        value <- apiCustomAttribute.value if value.nonEmpty
+      } yield ProductCustomAttribute(
+        name = name,
+        value = value,
+      )
+    }
+
+    def createProductImage(apiImage: ApiProductImage): Option[ProductImage] = {
+      for {
+        url <- apiImage.file if url.nonEmpty
+        height <- apiImage.height
+        width <- apiImage.width
+        displayCredit <- apiImage.displayCredit
+        credit <- apiImage.credit
+        alt <- apiImage.alt
+      } yield ProductImage(
+        url = url,
+        caption = apiImage.caption.getOrElse(""),
+        credit = credit,
+        height = height,
+        width = width,
+        displayCredit = displayCredit,
+        alt = alt,
+      )
+    }
+
+    ProductBlockElement(
+      content = product.content
+        .getOrElse(List())
+        .flatMap { element =>
+          PageElement.make(
+            element,
+            addAffiliateLinks,
+            pageUrl,
+            atoms,
+            isMainBlock = false,
+            isImmersive,
+            campaigns,
+            calloutsUrl,
+            overrideImage = None,
+            edition,
+            webPublicationDate,
+            isGallery,
+            isTheFilterUS,
+          )
+        }
+        .toSeq,
+      productName = product.productName.getOrElse(""),
+      brandName = product.brandName.getOrElse(""),
+      primaryHeadingHtml = product.primaryHeading.getOrElse(""),
+      secondaryHeadingHtml = product.secondaryHeading.getOrElse(""),
+      starRating = product.starRating.getOrElse("none-selected"),
+      productCtas = product.productCtas
+        .getOrElse(Seq.empty)
+        .flatMap(cta => createProductCta(cta, pageUrl, addAffiliateLinks, isTheFilterUS))
+        .toList,
+      customAttributes = product.customAttributes
+        .getOrElse(Seq.empty)
+        .flatMap(apiAttr => createProductCustomAttribute(apiAttr))
+        .toList,
+      image = product.image.flatMap(apiImage => createProductImage(apiImage)),
+      displayType = product.displayType,
+    )
+
+  }
+
   private[this] def ensureHTTPS(url: String): String = {
     val http = "http://"
 

common/app/model/liveblog/BlockElement.scala

@@ -183,6 +183,7 @@ object BlockElement {
       case ElementType.List          => Some(UnsupportedBlockElement(None))
       case Timeline                  => Some(UnsupportedBlockElement(None))
       case Link                      => Some(UnsupportedBlockElement(None))
+      case Product                   => Some(UnsupportedBlockElement(None))
     }
   }
 

common/app/views/support/HtmlCleaner.scala

@@ -910,18 +910,21 @@ object AffiliateLinksCleaner {
       isTheFilterUS: Boolean,
   ): Option[String] = {
     val skimlinksId = if (isTheFilterUS) skimlinksUSId else skimlinksDefaultId
-    url match {
+    val httpsUrl = url.map(ensureHttps)
+    httpsUrl match {
       case Some(link) if addAffiliateLinks && SkimLinksCache.isSkimLink(link) =>
         Some(linkToSkimLink(link, pageUrl, skimlinksId))
-      case _ => url
+      case _ => httpsUrl
     }
   }
 
+  def ensureHttps(url: String): String = url.replace("http:", "https:")
+
   def isAffiliatable(element: Element): Boolean =
     element.tagName == "a" && SkimLinksCache.isSkimLink(element.attr("href"))
 
   def linkToSkimLink(link: String, pageUrl: String, skimlinksId: String): String = {
-    val urlEncodedLink = URLEncode(link)
+    val urlEncodedLink = URLEncode(ensureHttps(link))
     s"https://go.skimresources.com/?id=$skimlinksId&url=$urlEncodedLink&sref=$host$pageUrl"
   }
 

common/test/views/support/cleaner/AffiliateLinksCleanerTest.scala

@@ -15,6 +15,14 @@ class AffiliateLinksCleanerTest extends AnyFlatSpec with Matchers {
     )
   }
 
+  "linkToSkimLink" should "replace http: with https: in the original link" in {
+    val link = "http://www.piratendating.nl/"
+    val pageUrl = "/guardian-pirates/soulmates"
+    linkToSkimLink(link, pageUrl, "123") should equal(
+      s"https://go.skimresources.com/?id=123&url=https%3A%2F%2Fwww.piratendating.nl%2F&sref=${Configuration.site.host}/guardian-pirates/soulmates",
+    )
+  }
+
   "shouldAddAffiliateLinks" should "correctly determine when to add affiliate links" in {
     // the switch is respected
     shouldAddAffiliateLinks(

project/Dependencies.scala

@@ -6,8 +6,8 @@ object Dependencies {
   val identityLibVersion = "4.31"
   val awsVersion = "1.12.791"
   val awsSdk2Version = "2.35.10"
-  val capiVersion = "37.1.0"
-  val faciaVersion = "23.0.0"
+  val capiVersion = "38.0.0"
+  val faciaVersion = "24.0.0"
   val dispatchVersion = "0.13.1"
   val romeVersion = "1.0"
   val jerseyVersion = "1.19.4"
@@ -30,7 +30,7 @@ object Dependencies {
   val commonsIo = "commons-io" % "commons-io" % "2.16.1"
   val cssParser = "net.sourceforge.cssparser" % "cssparser" % "0.9.30"
   val contentApiClient = "com.gu" %% "content-api-client" % capiVersion
-  val contentApiModelsJson = "com.gu" %% "content-api-models-json" % "31.0.0"
+  val contentApiModelsJson = "com.gu" %% "content-api-models-json" % "32.0.0"
   val faciaFapiScalaClient = "com.gu" %% "fapi-client-play30" % faciaVersion
   val identityCookie = "com.gu.identity" %% "identity-cookie" % identityLibVersion