Add scalafmt to the project

.scalafmt.conf

@@ -0,0 +1 @@
+version = 2.7.5

admin-tools/dev/app/AdminToolsComponents.scala

@@ -8,19 +8,23 @@ import router.Routes
 
 object AdminToolsComponents {
   def config(resources: GridConfigResources) = new AdminToolsConfig(
-    resources.configuration ++ Configuration.from(Map(
-      "domain.root" -> "local.dev-gutools.co.uk",
-      "auth.keystore.bucket" -> "not-used",
-      "thrall.kinesis.stream.name"-> "not-used",
-      "thrall.kinesis.lowPriorityStream.name"-> "not-used"
-    ))
+    resources.configuration ++ Configuration.from(
+      Map(
+        "domain.root" -> "local.dev-gutools.co.uk",
+        "auth.keystore.bucket" -> "not-used",
+        "thrall.kinesis.stream.name" -> "not-used",
+        "thrall.kinesis.lowPriorityStream.name" -> "not-used"
+      )
+    )
   )
 }
 
-class AdminToolsComponents(context: Context) extends GridComponents(context, AdminToolsComponents.config) {
+class AdminToolsComponents(context: Context)
+    extends GridComponents(context, AdminToolsComponents.config) {
   final override val buildInfo = utils.buildinfo.BuildInfo
 
   val controller = new AdminToolsCtr(config, controllerComponents)
 
-  override lazy val router = new Routes(httpErrorHandler, controller, management)
+  override lazy val router =
+    new Routes(httpErrorHandler, controller, management)
 }

admin-tools/dev/app/AppLoader.scala

@@ -1,3 +1,4 @@
 import com.gu.mediaservice.lib.play.GridAppLoader
 
-class AppLoader extends GridAppLoader("admin-tools", new AdminToolsComponents(_))
+class AppLoader
+    extends GridAppLoader("admin-tools", new AdminToolsComponents(_))

admin-tools/dev/app/controllers/AdminToolsCtr.scala

@@ -3,17 +3,30 @@ package controllers
 import com.gu.mediaservice.lib.argo.ArgoHelpers
 import com.gu.mediaservice.lib.argo.model.Link
 import com.gu.mediaservice.model.Image._
-import com.gu.mediaservice.{FullImageProjectionFailed, FullImageProjectionSuccess, ImageDataMerger, ImageDataMergerConfig}
+import com.gu.mediaservice.{
+  FullImageProjectionFailed,
+  FullImageProjectionSuccess,
+  ImageDataMerger,
+  ImageDataMergerConfig
+}
 import lib.AdminToolsConfig
 import play.api.libs.json.Json
 import play.api.mvc.{BaseController, ControllerComponents}
 
 import scala.concurrent.ExecutionContext
 
-class AdminToolsCtr(config: AdminToolsConfig, override val controllerComponents: ControllerComponents)(implicit val ec: ExecutionContext)
-  extends BaseController with ArgoHelpers {
+class AdminToolsCtr(
+    config: AdminToolsConfig,
+    override val controllerComponents: ControllerComponents
+)(implicit val ec: ExecutionContext)
+    extends BaseController
+    with ArgoHelpers {
 
-  private val cfg = ImageDataMergerConfig(apiKey = config.apiKey, domainRoot = config.domainRoot, imageLoaderEndpointOpt = None)
+  private val cfg = ImageDataMergerConfig(
+    apiKey = config.apiKey,
+    domainRoot = config.domainRoot,
+    imageLoaderEndpointOpt = None
+  )
 
   private val merger = new ImageDataMerger(cfg)
 
@@ -39,13 +52,23 @@ class AdminToolsCtr(config: AdminToolsConfig, override val controllerComponents:
           case Some(img) =>
             Ok(Json.toJson(img)).as(ArgoMediaType)
           case _ =>
-            respondError(NotFound, "not-found", s"image with mediaId: $mediaId not found")
+            respondError(
+              NotFound,
+              "not-found",
+              s"image with mediaId: $mediaId not found"
+            )
         }
       case FullImageProjectionFailed(expMessage, downstreamMessage) =>
-        respondError(InternalServerError, "image-projection-failed", Json.obj(
-          "errorMessage" -> expMessage,
-          "downstreamErrorMessage" -> downstreamMessage
-        ).toString)
+        respondError(
+          InternalServerError,
+          "image-projection-failed",
+          Json
+            .obj(
+              "errorMessage" -> expMessage,
+              "downstreamErrorMessage" -> downstreamMessage
+            )
+            .toString
+        )
     }
   }
 }

admin-tools/dev/app/lib/AdminToolsConfig.scala

@@ -3,7 +3,8 @@ package lib
 import com.gu.mediaservice.lib.config.CommonConfig
 import play.api.Configuration
 
-class AdminToolsConfig(playAppConfiguration: Configuration) extends CommonConfig(playAppConfiguration) {
+class AdminToolsConfig(playAppConfiguration: Configuration)
+    extends CommonConfig(playAppConfiguration) {
   // hardcoded for dev
   val apiKey: String = "dev-"
 

admin-tools/lambda/src/main/scala/com/gu/mediaservice/BatchIndexLambdaHandler.scala

@@ -17,12 +17,12 @@ class BatchIndexLambdaHandler {
     threshold = sys.env.get("LATENCY_THRESHOLD").map(t => Integer.parseInt(t)),
     maxSize = sys.env("MAX_SIZE").toInt,
     startState = IndexInputCreation.get(sys.env("START_STATE").toInt),
-    checkerStartState = IndexInputCreation.get(sys.env("CHECKER_START_STATE").toInt)
+    checkerStartState =
+      IndexInputCreation.get(sys.env("CHECKER_START_STATE").toInt)
   )
 
   private val batchIndex = new BatchIndexHandler(cfg)
 
-
   def handleRequest() = {
     batchIndex.processImages()
   }

admin-tools/lambda/src/main/scala/com/gu/mediaservice/ImageProjectionLambdaHandler.scala

@@ -1,7 +1,10 @@
 package com.gu.mediaservice
 
 import com.amazonaws.services.lambda.runtime.Context
-import com.amazonaws.services.lambda.runtime.events.{APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent}
+import com.amazonaws.services.lambda.runtime.events.{
+  APIGatewayProxyRequestEvent,
+  APIGatewayProxyResponseEvent
+}
 import com.gu.mediaservice.lib.auth.provider.ApiKeyAuthenticationProvider
 import com.gu.mediaservice.model.Image
 import com.typesafe.scalalogging.LazyLogging
@@ -12,7 +15,10 @@ import scala.concurrent.ExecutionContext.Implicits.global
 
 class ImageProjectionLambdaHandler extends LazyLogging {
 
-  def handleRequest(event: APIGatewayProxyRequestEvent, context: Context): APIGatewayProxyResponseEvent = {
+  def handleRequest(
+      event: APIGatewayProxyRequestEvent,
+      context: Context
+  ): APIGatewayProxyResponseEvent = {
 
     logger.info(s"handleImageProjection event: $event")
 
@@ -27,14 +33,19 @@ class ImageProjectionLambdaHandler extends LazyLogging {
 
     apiKey match {
       case Some(key) =>
-        val cfg: ImageDataMergerConfig = ImageDataMergerConfig(apiKey = key, domainRoot = domainRoot, imageLoaderEndpointOpt = imageLoaderEndpoint)
+        val cfg: ImageDataMergerConfig = ImageDataMergerConfig(
+          apiKey = key,
+          domainRoot = domainRoot,
+          imageLoaderEndpointOpt = imageLoaderEndpoint
+        )
         if (!cfg.isValidApiKey()) return getUnauthorisedResponse
 
         logger.info(s"starting handleImageProjection for mediaId=$mediaId")
         logger.info(s"with config: $cfg")
 
         val merger = new ImageDataMerger(cfg)
-        val result: FullImageProjectionResult = merger.getMergedImageData(mediaId.asInstanceOf[String])
+        val result: FullImageProjectionResult =
+          merger.getMergedImageData(mediaId.asInstanceOf[String])
         result match {
           case FullImageProjectionSuccess(mayBeImage) =>
             mayBeImage match {
@@ -60,19 +71,27 @@ class ImageProjectionLambdaHandler extends LazyLogging {
   }
 
   private def getNotFoundResponse(mediaId: String) = {
-    val emptyRes = Json.obj("message" -> s"image with id=$mediaId not-found").toString
+    val emptyRes =
+      Json.obj("message" -> s"image with id=$mediaId not-found").toString
     logger.info(s"image not projected \n $emptyRes")
     new APIGatewayProxyResponseEvent()
       .withStatusCode(404)
       .withHeaders(Map("content-type" -> "application/json").asJava)
       .withBody(emptyRes)
   }
 
-  private def getErrorFoundResponse(message: String, downstreamMessage: String) = {
-    val res = Json.obj("message" -> Json.obj(
-      "errorMessage" -> message,
-      "downstreamErrorMessage" -> downstreamMessage
-    )).toString
+  private def getErrorFoundResponse(
+      message: String,
+      downstreamMessage: String
+  ) = {
+    val res = Json
+      .obj(
+        "message" -> Json.obj(
+          "errorMessage" -> message,
+          "downstreamErrorMessage" -> downstreamMessage
+        )
+      )
+      .toString
 
     logger.info(s"image not projected due to error \n $res")
 
@@ -83,7 +102,8 @@ class ImageProjectionLambdaHandler extends LazyLogging {
   }
 
   private def getUnauthorisedResponse = {
-    val res = Json.obj("message" -> s"missing or invalid api key header").toString
+    val res =
+      Json.obj("message" -> s"missing or invalid api key header").toString
 
     new APIGatewayProxyResponseEvent()
       .withStatusCode(401)
@@ -93,8 +113,10 @@ class ImageProjectionLambdaHandler extends LazyLogging {
 
   private def getAuthKeyFrom(headers: Map[String, String]) = {
     // clients like curl or API gateway may lowerCases custom header names, yay!
-    headers.find {
-      case (k, _) => k.equalsIgnoreCase(ApiKeyAuthenticationProvider.apiKeyHeaderName)
-    }.map(_._2)
+    headers
+      .find { case (k, _) =>
+        k.equalsIgnoreCase(ApiKeyAuthenticationProvider.apiKeyHeaderName)
+      }
+      .map(_._2)
   }
 }

admin-tools/scripts/src/main/scala/com/gu/mediaservice/ImagesGroupByProgressState.scala

@@ -7,7 +7,8 @@ import scala.collection.JavaConverters._
 
 object ImagesGroupByProgressState extends App with LazyLogging {
 
-  if (args.isEmpty) throw new IllegalArgumentException("please provide dynamo table name")
+  if (args.isEmpty)
+    throw new IllegalArgumentException("please provide dynamo table name")
 
   import InputIdsStore._
 
@@ -19,7 +20,8 @@ object ImagesGroupByProgressState extends App with LazyLogging {
 
     def stateNameToCount(progressType: ProduceProgress): (String, Int) = {
       logger.info(s"calculating stateNameToCount for $progressType")
-      val queryRes = stateIndex.query(getAllMediaIdsWithinProgressQuery(progressType))
+      val queryRes =
+        stateIndex.query(getAllMediaIdsWithinProgressQuery(progressType))
       val result = progressType.name -> queryRes.iterator.asScala.length
       logger.info(s"result=$result")
       result
@@ -42,7 +44,7 @@ object ImagesGroupByProgressState extends App with LazyLogging {
       stateNameToCount(NotFound),
       stateNameToCount(KnownError),
       stateNameToCount(NotStarted),
-      stateNameToCount(InProgress),
+      stateNameToCount(InProgress)
     ).mkString("\n")
 
     logger.info(s"results from dynamoTable=$dynamoTable")

admin-tools/scripts/src/main/scala/com/gu/mediaservice/ResetImageBatchIndexTable.scala

@@ -8,7 +8,8 @@ import scala.concurrent.duration.Duration
 
 object ResetImageBatchIndexTable extends App with LazyLogging {
 
-  if (args.isEmpty) throw new IllegalArgumentException("please provide dynamo table name")
+  if (args.isEmpty)
+    throw new IllegalArgumentException("please provide dynamo table name")
 
   private val dynamoTable = args(0)
   private val ddbClient = AwsHelpers.buildDynamoTableClient(dynamoTable)

admin-tools/scripts/src/main/scala/com/gu/mediaservice/ResetKnownErrors.scala

@@ -8,7 +8,8 @@ import scala.collection.JavaConverters._
 
 object ResetKnownErrors extends App with LazyLogging {
 
-  if (args.isEmpty) throw new IllegalArgumentException("please provide dynamo table name")
+  if (args.isEmpty)
+    throw new IllegalArgumentException("please provide dynamo table name")
 
   import IndexInputCreation._
   import InputIdsStore._
@@ -21,13 +22,18 @@ object ResetKnownErrors extends App with LazyLogging {
     val ignoredAtThisScript = 100
     val InputIdsStore = new InputIdsStore(ddbClient, ignoredAtThisScript)
 
-    val mediaIDsWithKnownErrors = stateIndex.query(getAllMediaIdsWithinProgressQuery(KnownError))
-      .asScala.toList.map { it =>
-      val json = Json.parse(it.toJSON).as[JsObject]
-      (json \ PKField).as[String]
-    }
-
-    logger.info(s"got ${mediaIDsWithKnownErrors.size}, mediaIds blacklisted as KnownError")
+    val mediaIDsWithKnownErrors = stateIndex
+      .query(getAllMediaIdsWithinProgressQuery(KnownError))
+      .asScala
+      .toList
+      .map { it =>
+        val json = Json.parse(it.toJSON).as[JsObject]
+        (json \ PKField).as[String]
+      }
+
+    logger.info(
+      s"got ${mediaIDsWithKnownErrors.size}, mediaIds blacklisted as KnownError"
+    )
     InputIdsStore.resetItemsState(mediaIDsWithKnownErrors)
   }
 

auth/app/auth/AuthComponents.scala

@@ -7,22 +7,28 @@ import play.api.{Configuration, Environment}
 import play.api.http.HttpConfiguration
 import router.Routes
 
-class AuthComponents(context: Context) extends GridComponents(context, new AuthConfig(_)) {
-  final override lazy val httpConfiguration = AuthHttpConfig(configuration, context.environment)
+class AuthComponents(context: Context)
+    extends GridComponents(context, new AuthConfig(_)) {
+  final override lazy val httpConfiguration =
+    AuthHttpConfig(configuration, context.environment)
 
   final override val buildInfo = utils.buildinfo.BuildInfo
 
-  val controller = new AuthController(auth, providers, config, controllerComponents)
-  val permissionsAwareManagement = new ManagementWithPermissions(controllerComponents, controller, buildInfo)
+  val controller =
+    new AuthController(auth, providers, config, controllerComponents)
+  val permissionsAwareManagement =
+    new ManagementWithPermissions(controllerComponents, controller, buildInfo)
 
-  override val router = new Routes(httpErrorHandler, controller, permissionsAwareManagement)
+  override val router =
+    new Routes(httpErrorHandler, controller, permissionsAwareManagement)
 }
 
 object AuthHttpConfig {
-  def apply(playConfig: Configuration, environment: Environment): HttpConfiguration = {
+  def apply(
+      playConfig: Configuration,
+      environment: Environment
+  ): HttpConfiguration = {
     val base = HttpConfiguration.fromConfiguration(playConfig, environment)
-    base.copy(session =
-      base.session.copy(sameSite = None)
-    )
+    base.copy(session = base.session.copy(sameSite = None))
   }
 }

auth/app/auth/AuthConfig.scala

@@ -2,7 +2,8 @@ package auth
 
 import com.gu.mediaservice.lib.config.{CommonConfig, GridConfigResources}
 
-class AuthConfig(resources: GridConfigResources) extends CommonConfig(resources.configuration) {
+class AuthConfig(resources: GridConfigResources)
+    extends CommonConfig(resources.configuration) {
   val rootUri: String = services.authBaseUri
   val mediaApiUri: String = services.apiBaseUri
   val kahunaUri = services.kahunaBaseUri