Update Play (2.6.15) and reformat code

app/org/thp/cortex/controllers/AnalyzerCtrl.scala

@@ -45,33 +45,33 @@ class AnalyzerCtrl @Inject() (
   }
 
   private val emptyAnalyzerDefinitionJson = Json.obj(
-    "version" -> "0.0",
-    "description" -> "unknown",
-    "dataTypeList" -> Nil,
-    "author" -> "unknown",
-    "url" -> "unknown",
-    "license" -> "unknown")
+    "version" → "0.0",
+    "description" → "unknown",
+    "dataTypeList" → Nil,
+    "author" → "unknown",
+    "url" → "unknown",
+    "license" → "unknown")
 
   private def analyzerJson(analyzer: Worker, analyzerDefinition: Option[WorkerDefinition]) = {
     analyzer.toJson ++ analyzerDefinition.fold(emptyAnalyzerDefinitionJson) { ad ⇒
       Json.obj(
-        "maxTlp" -> (analyzer.config \ "max_tlp").asOpt[JsNumber],
-        "maxPap" -> (analyzer.config \ "max_pap").asOpt[JsNumber],
-        "version" -> ad.version,
-        "description" -> ad.description,
-        "author" -> ad.author,
-        "url" -> ad.url,
-        "license" -> ad.license,
-        "baseConfig" -> ad.baseConfiguration)
-    } + ("analyzerDefinitionId" -> JsString(analyzer.workerDefinitionId())) // For compatibility reason
+        "maxTlp" → (analyzer.config \ "max_tlp").asOpt[JsNumber],
+        "maxPap" → (analyzer.config \ "max_pap").asOpt[JsNumber],
+        "version" → ad.version,
+        "description" → ad.description,
+        "author" → ad.author,
+        "url" → ad.url,
+        "license" → ad.license,
+        "baseConfig" → ad.baseConfiguration)
+    } + ("analyzerDefinitionId" → JsString(analyzer.workerDefinitionId())) // For compatibility reason
   }
 
   private def analyzerJson(isAdmin: Boolean)(analyzer: Worker): Future[JsObject] = {
     workerSrv.getDefinition(analyzer.workerDefinitionId())
       .map(analyzerDefinition ⇒ analyzerJson(analyzer, Some(analyzerDefinition)))
       .recover { case _ ⇒ analyzerJson(analyzer, None) }
       .map {
-        case a if isAdmin ⇒ a + ("configuration" -> Json.parse(analyzer.configuration()))
+        case a if isAdmin ⇒ a + ("configuration" → Json.parse(analyzer.configuration()))
         case a            ⇒ a
       }
   }

app/org/thp/cortex/controllers/JobCtrl.scala

@@ -84,32 +84,32 @@ class JobCtrl @Inject() (
             .collect {
               case artifact if artifact.data().isDefined ⇒
                 Json.obj(
-                  "data" -> artifact.data(),
-                  "dataType" -> artifact.dataType(),
-                  "message" -> artifact.message(),
-                  "tags" -> artifact.tags(),
-                  "tlp" -> artifact.tlp())
+                  "data" → artifact.data(),
+                  "dataType" → artifact.dataType(),
+                  "message" → artifact.message(),
+                  "tags" → artifact.tags(),
+                  "tlp" → artifact.tlp())
               case artifact if artifact.attachment().isDefined ⇒
                 artifact.attachment().fold(JsObject.empty) { a ⇒
                   Json.obj(
-                    "attachment" ->
+                    "attachment" →
                       Json.obj(
-                        "contentType" -> a.contentType,
-                        "id" -> a.id,
-                        "name" -> a.name,
-                        "size" -> a.size),
-                    "message" -> artifact.message(),
-                    "tags" -> artifact.tags(),
-                    "tlp" -> artifact.tlp())
+                        "contentType" → a.contentType,
+                        "id" → a.id,
+                        "name" → a.name,
+                        "size" → a.size),
+                    "message" → artifact.message(),
+                    "tags" → artifact.tags(),
+                    "tlp" → artifact.tlp())
                 }
             }
             .runWith(Sink.seq)
         } yield Json.obj(
-          "summary" -> Json.parse(report.summary()),
-          "full" -> Json.parse(report.full()),
-          "success" -> true,
-          "artifacts" -> artifacts,
-          "operations" -> Json.parse(report.operations()))
+          "summary" → Json.parse(report.summary()),
+          "full" → Json.parse(report.full()),
+          "success" → true,
+          "artifacts" → artifacts,
+          "operations" → Json.parse(report.operations()))
       case JobStatus.Failure ⇒
         val errorMessage = job.errorMessage().getOrElse("")
         Future.successful(Json.obj(
@@ -121,7 +121,7 @@ class JobCtrl @Inject() (
       case JobStatus.Deleted    ⇒ Future.successful(JsString("Deleted"))
     })
       .map { report ⇒
-        Json.toJson(job).as[JsObject] + ("report" -> report)
+        Json.toJson(job).as[JsObject] + ("report" → report)
       }
   }
 
@@ -133,7 +133,7 @@ class JobCtrl @Inject() (
     jobSrv.getForUser(request.userId, jobId)
       .flatMap {
         case job if job.status() == JobStatus.InProgress || job.status() == JobStatus.Waiting ⇒
-          println(s"job status is ${job.status()} => wait")
+          println(s"job status is ${job.status()} ⇒ wait")
           val duration = Duration(atMost).asInstanceOf[FiniteDuration]
           implicit val timeout: Timeout = Timeout(duration)
           (auditActor ? Register(jobId, duration))
@@ -142,7 +142,7 @@ class JobCtrl @Inject() (
             .withTimeout(duration, ())
             .flatMap(_ ⇒ getJobWithReport(request.userId, jobId))
         case job ⇒
-          println(s"job status is ${job.status()} => send it directly")
+          println(s"job status is ${job.status()} ⇒ send it directly")
           getJobWithReport(request.userId, job)
       }
       .map(Ok(_))

app/org/thp/cortex/controllers/ResponderCtrl.scala

@@ -45,24 +45,24 @@ class ResponderCtrl @Inject() (
   }
 
   private val emptyResponderDefinitionJson = Json.obj(
-    "version" -> "0.0",
-    "description" -> "unknown",
-    "dataTypeList" -> Nil,
-    "author" -> "unknown",
-    "url" -> "unknown",
-    "license" -> "unknown")
+    "version" → "0.0",
+    "description" → "unknown",
+    "dataTypeList" → Nil,
+    "author" → "unknown",
+    "url" → "unknown",
+    "license" → "unknown")
 
   private def responderJson(responder: Worker, responderDefinition: Option[WorkerDefinition]) = {
     responder.toJson ++ responderDefinition.fold(emptyResponderDefinitionJson) { ad ⇒
       Json.obj(
-        "maxTlp" -> (responder.config \ "max_tlp").asOpt[JsNumber],
-        "maxPap" -> (responder.config \ "max_pap").asOpt[JsNumber],
-        "version" -> ad.version,
-        "description" -> ad.description,
-        "author" -> ad.author,
-        "url" -> ad.url,
-        "license" -> ad.license,
-        "baseConfig" -> ad.baseConfiguration)
+        "maxTlp" → (responder.config \ "max_tlp").asOpt[JsNumber],
+        "maxPap" → (responder.config \ "max_pap").asOpt[JsNumber],
+        "version" → ad.version,
+        "description" → ad.description,
+        "author" → ad.author,
+        "url" → ad.url,
+        "license" → ad.license,
+        "baseConfig" → ad.baseConfiguration)
     }
   }
 
@@ -71,7 +71,7 @@ class ResponderCtrl @Inject() (
       .map(responderDefinition ⇒ responderJson(responder, Some(responderDefinition)))
       .recover { case _ ⇒ responderJson(responder, None) }
       .map {
-        case a if isAdmin ⇒ a + ("configuration" -> Json.parse(responder.configuration()))
+        case a if isAdmin ⇒ a + ("configuration" → Json.parse(responder.configuration()))
         case a            ⇒ a
       }
   }

app/org/thp/cortex/controllers/StatusCtrl.scala

@@ -36,7 +36,7 @@ class StatusCtrl @Inject() (
           "Play" → getVersion(classOf[AbstractController]),
           "Elastic4s" → getVersion(classOf[ElasticDsl]),
           "ElasticSearch client" → getVersion(classOf[org.elasticsearch.Build]),
-          "ElasticSearch cluster" -> versions.mkString(", ")),
+          "ElasticSearch cluster" → versions.mkString(", ")),
         "config" → Json.obj(
           "authType" → (authSrv match {
             case multiAuthSrv: MultiAuthSrv ⇒ multiAuthSrv.authProviders.map { a ⇒ JsString(a.name) }

app/org/thp/cortex/models/BaseConfig.scala

@@ -10,10 +10,10 @@ case class BaseConfig(name: String, workerNames: Seq[String], items: Seq[Configu
 object BaseConfig {
   implicit val writes: Writes[BaseConfig] = Writes[BaseConfig] { baseConfig ⇒
     Json.obj(
-      "name" -> baseConfig.name,
-      "workers" -> baseConfig.workerNames,
-      "configurationItems" -> baseConfig.items,
-      "config" -> baseConfig.config.fold(JsObject.empty)(_.jsonConfig))
+      "name" → baseConfig.name,
+      "workers" → baseConfig.workerNames,
+      "configurationItems" → baseConfig.items,
+      "config" → baseConfig.config.fold(JsObject.empty)(_.jsonConfig))
   }
   def global(tpe: WorkerType.Type) = {
     val typedItems = tpe match {

app/org/thp/cortex/models/Job.scala

@@ -38,7 +38,7 @@ trait JobAttributes {
 @Singleton
 class JobModel @Inject() () extends ModelDef[JobModel, Job]("job", "Job", "/job") with JobAttributes with AuditedModel {
 
-  override val removeAttribute: JsObject = Json.obj("status" -> JobStatus.Deleted)
+  override val removeAttribute: JsObject = Json.obj("status" → JobStatus.Deleted)
 
   override def defaultSortBy: Seq[String] = Seq("-createdAt")
 }
@@ -47,9 +47,9 @@ class Job(model: JobModel, attributes: JsObject) extends EntityDef[JobModel, Job
   val params: JsObject = Try(Json.parse(parameters()).as[JsObject]).getOrElse(JsObject.empty)
 
   override def toJson: JsObject = {
-    val output = super.toJson + ("date" -> Json.toJson(createdAt))
+    val output = super.toJson + ("date" → Json.toJson(createdAt))
     input().fold(output)(i ⇒ output +
-      ("input" -> Json.parse(i))) +
-      ("parameters" -> params)
+      ("input" → Json.parse(i))) +
+      ("parameters" → params)
   }
 }

app/org/thp/cortex/models/Migration.scala

@@ -23,28 +23,28 @@ class Migration @Inject() (
   def endMigration(version: Int): Future[Unit] = {
     userSrv.inInitAuthContext { implicit authContext ⇒
       organizationSrv.create(Fields(Json.obj(
-        "name" -> "cortex",
-        "description" -> "Default organization",
-        "status" -> "Active")))
+        "name" → "cortex",
+        "description" → "Default organization",
+        "status" → "Active")))
         .transform { case _ ⇒ Success(()) } // ignore errors (already exist)
     }
   }
 
   val operations: PartialFunction[DatabaseState, Seq[Operation]] = {
     case DatabaseState(1) ⇒ Seq(
       // add type to analyzer
-      addAttribute("analyzer", "type" -> JsString("analyzer")),
+      addAttribute("analyzer", "type" → JsString("analyzer")),
 
       renameAttribute("job", "workerDefinitionId", "analyzerDefinitionId"),
       renameAttribute("job", "workerId", "analyzerId"),
       renameAttribute("job", "workerName", "analyzerName"),
 
       renameEntity("analyzer", "worker"),
       renameAttribute("worker", "workerDefinitionId", "analyzerDefinitionId"),
-      addAttribute("worker", "type" -> JsString(WorkerType.analyzer.toString)),
+      addAttribute("worker", "type" → JsString(WorkerType.analyzer.toString)),
 
       renameEntity("analyzerConfig", "workerConfig"),
-      addAttribute("workerConfig", "type" -> JsString(WorkerType.analyzer.toString)))
+      addAttribute("workerConfig", "type" → JsString(WorkerType.analyzer.toString)))
 
     case _ ⇒ Nil
   }

app/org/thp/cortex/models/Organization.scala

@@ -34,7 +34,7 @@ class OrganizationModel @Inject() (
   private lazy val logger = Logger(getClass)
   lazy val userModel = userModelProvider.get
   lazy val workerModel = workerModelProvider.get
-  override def removeAttribute = Json.obj("status" -> "Locked")
+  override def removeAttribute = Json.obj("status" → "Locked")
 
   override def creationHook(parent: Option[BaseEntity], attrs: JsObject): Future[JsObject] =
     Future.successful {
@@ -91,5 +91,5 @@ class OrganizationModel @Inject() (
 }
 
 class Organization(model: OrganizationModel, attributes: JsObject) extends EntityDef[OrganizationModel, Organization](model, attributes) with OrganizationAttributes {
-  override def toJson: JsObject = super.toJson + ("name" -> JsString(id))
+  override def toJson: JsObject = super.toJson + ("name" → JsString(id))
 }

app/org/thp/cortex/models/User.scala

@@ -42,5 +42,5 @@ class User(model: UserModel, attributes: JsObject) extends EntityDef[UserModel,
   override def toJson: JsObject = super.toJson +
     ("roles" → JsArray(roles().map(r ⇒ JsString(r.name.toLowerCase())))) +
     ("hasKey" → JsBoolean(key().isDefined)) +
-    ("hasPassword" -> JsBoolean(password().isDefined))
+    ("hasPassword" → JsBoolean(password().isDefined))
 }

app/org/thp/cortex/models/Worker.scala

@@ -46,7 +46,7 @@ class WorkerModel @Inject() (organizationModel: OrganizationModel) extends Child
       organizationId ← parent.map(_.id)
       name ← (attrs \ "name").asOpt[String]
     } yield hasher.fromString(s"${organizationId}_$name").head.toString
-    Future.successful(attrs + ("_id" -> JsString(id.getOrElse("<null>"))))
+    Future.successful(attrs + ("_id" → JsString(id.getOrElse("<null>"))))
   }
 }
 

app/org/thp/cortex/models/WorkerDefinition.scala

@@ -49,14 +49,14 @@ case class ConfigurationDefinitionItem(
     (config \ name).toOption
       .orElse(defaultValue)
       .map {
-        case JsArray(values) if isMulti ⇒ values.validatedBy(check).map(a ⇒ name -> JsArray(a))
-        case value if !isMulti          ⇒ check(value).map(name -> _)
+        case JsArray(values) if isMulti ⇒ values.validatedBy(check).map(a ⇒ name → JsArray(a))
+        case value if !isMulti          ⇒ check(value).map(name → _)
         case value                      ⇒ Bad(One(InvalidFormatAttributeError(name, `type`.toString, JsonInputValue(value))))
       }
       .getOrElse {
-        if (isMulti) Good(name -> JsArray.empty)
+        if (isMulti) Good(name → JsArray.empty)
         else if (isRequired) Bad(One(MissingAttributeError(name)))
-        else Good(name -> JsNull)
+        else Good(name → JsNull)
       }
   }
 }
@@ -131,15 +131,15 @@ object WorkerDefinition {
     Reads.pure(workerType))(WorkerDefinition.apply _)
   implicit val writes: Writes[WorkerDefinition] = Writes[WorkerDefinition] { workerDefinition ⇒
     Json.obj(
-      "id" -> workerDefinition.id,
-      "name" -> workerDefinition.name,
-      "version" -> workerDefinition.version,
-      "description" -> workerDefinition.description,
-      "dataTypeList" -> workerDefinition.dataTypeList,
-      "author" -> workerDefinition.author,
-      "url" -> workerDefinition.url,
-      "license" -> workerDefinition.license,
-      "baseConfig" -> workerDefinition.baseConfiguration,
-      "configurationItems" -> workerDefinition.configurationItems)
+      "id" → workerDefinition.id,
+      "name" → workerDefinition.name,
+      "version" → workerDefinition.version,
+      "description" → workerDefinition.description,
+      "dataTypeList" → workerDefinition.dataTypeList,
+      "author" → workerDefinition.author,
+      "url" → workerDefinition.url,
+      "license" → workerDefinition.license,
+      "baseConfig" → workerDefinition.baseConfiguration,
+      "configurationItems" → workerDefinition.configurationItems)
   }
 }

app/org/thp/cortex/services/AuditSrv.scala

@@ -44,13 +44,13 @@ class AuditActor @Inject() (
     case Register(jobId, timeout) ⇒
       logger.info(s"Register new listener for job $jobId ($sender)")
       val newActorList = registration.getOrElse(jobId, Nil) :+ sender
-      registration += (jobId -> newActorList)
+      registration += (jobId → newActorList)
       context.system.scheduler.scheduleOnce(timeout, self, Unregister(jobId, sender))
 
     case Unregister(jobId, actorRef) ⇒
       logger.info(s"Unregister listener for job $jobId ($actorRef)")
       val newActorList = registration.getOrElse(jobId, Nil).filterNot(_ == actorRef)
-      registration += (jobId -> newActorList)
+      registration += (jobId → newActorList)
 
     case AuditOperation(EntityExtractor(model, id, routing), action, details, authContext, date) ⇒
       if (model.modelName == "job" && action == AuditableAction.Update) {

app/org/thp/cortex/services/ErrorHandler.scala

@@ -26,7 +26,7 @@ class ErrorHandler extends HttpErrorHandler {
       case AuthenticationError(message)        ⇒ Some(Status.UNAUTHORIZED → Json.obj("type" → "AuthenticationError", "message" → message))
       case AuthorizationError(message)         ⇒ Some(Status.FORBIDDEN → Json.obj("type" → "AuthorizationError", "message" → message))
       case UpdateError(_, message, attributes) ⇒ Some(Status.INTERNAL_SERVER_ERROR → Json.obj("type" → "UpdateError", "message" → message, "object" → attributes))
-      case rle: RateLimitExceeded              ⇒ Some(Status.TOO_MANY_REQUESTS -> Json.obj("type" -> "RateLimitExceeded", "message" -> rle.getMessage))
+      case rle: RateLimitExceeded              ⇒ Some(Status.TOO_MANY_REQUESTS → Json.obj("type" → "RateLimitExceeded", "message" → rle.getMessage))
       case InternalError(message)              ⇒ Some(Status.INTERNAL_SERVER_ERROR → Json.obj("type" → "InternalError", "message" → message))
       case nfe: NumberFormatException          ⇒ Some(Status.BAD_REQUEST → Json.obj("type" → "NumberFormatException", "message" → ("Invalid format " + nfe.getMessage)))
       case NotFoundError(message)              ⇒ Some(Status.NOT_FOUND → Json.obj("type" → "NotFoundError", "message" → message))
@@ -43,8 +43,8 @@ class ErrorHandler extends HttpErrorHandler {
           case Some((_, j)) ⇒ j
         }
         Some(Status.MULTI_STATUS → Json.obj("type" → "MultiError", "error" → message, "suberrors" → suberrors))
-      case JobNotFoundError(jobId)         ⇒ Some(Status.NOT_FOUND -> Json.obj("type" -> "JobNotFoundError", "message" -> s"Job $jobId not found"))
-      case WorkerNotFoundError(analyzerId) ⇒ Some(Status.NOT_FOUND -> Json.obj("type" -> "AnalyzerNotFoundError", "message" -> s"analyzer $analyzerId not found"))
+      case JobNotFoundError(jobId)         ⇒ Some(Status.NOT_FOUND → Json.obj("type" → "JobNotFoundError", "message" → s"Job $jobId not found"))
+      case WorkerNotFoundError(analyzerId) ⇒ Some(Status.NOT_FOUND → Json.obj("type" → "AnalyzerNotFoundError", "message" → s"analyzer $analyzerId not found"))
       case _: IndexNotFoundException       ⇒ Some(520 → JsNull)
       case qse: QueryShardException        ⇒ Some(Status.BAD_REQUEST → Json.obj("type" → "Invalid search query", "message" → qse.getMessage))
       case t: Throwable                    ⇒ Option(t.getCause).flatMap(toErrorResult)