#28 Format code using scalariform

TheHive-Project · Nov 29, 2016 · b862f87 · b862f87
1 parent 27fc76e
commit b862f87
Show file tree

Hide file tree

Showing 53 changed files with 1,109 additions and 1,069 deletions.
diff --git a/build.sbt b/build.sbt
@@ -115,7 +115,7 @@ import com.typesafe.sbt.SbtScalariform.ScalariformKeys
 
 SbtScalariform.defaultScalariformSettings
 
-ScalariformKeys.preferences := ScalariformKeys.preferences.value
+ScalariformKeys.preferences in ThisBuild := ScalariformKeys.preferences.value
   .setPreference(AlignParameters, false)
 //  .setPreference(FirstParameterOnNewline, Force)
   .setPreference(AlignArguments, true)
@@ -136,6 +136,7 @@ ScalariformKeys.preferences := ScalariformKeys.preferences.value
   .setPreference(PlaceScaladocAsterisksBeneathSecondAsterisk, false)
   .setPreference(PreserveSpaceBeforeArguments, false)
 //  .setPreference(PreserveDanglingCloseParenthesis, false)
+  .setPreference(DanglingCloseParenthesis, Prevent)
   .setPreference(RewriteArrowSymbols, true)
   .setPreference(SpaceBeforeColon, false)
 //  .setPreference(SpaceBeforeContextColon, false)

diff --git a/thehive-backend/app/connectors/Connectors.scala b/thehive-backend/app/connectors/Connectors.scala
@@ -19,11 +19,11 @@ trait Connector {
 
 class ConnectorRouter @Inject() (connectors: immutable.Set[Connector]) extends SimpleRouter {
   def routes = {
-    case request @ p"/$connector/$path<.*>" =>
+    case request @ p"/$connector/$path<.*>" ⇒
       connectors
         .find(_.name == connector)
         .flatMap(_.router.withPrefix(s"/$connector/").handlerFor(request))
-        .getOrElse(Action { _ => Results.NotFound(s"connector $connector not found") })
+        .getOrElse(Action { _ ⇒ Results.NotFound(s"connector $connector not found") })
   }
 }
 

diff --git a/thehive-backend/app/controllers/Analyzer.scala b/thehive-backend/app/controllers/Analyzer.scala
@@ -25,13 +25,13 @@ class AnalyzerCtrl @Inject() (
     implicit val ec: ExecutionContext) extends Controller with Status {
 
   @Timed
-  def get(id: String) = authenticated(Role.read).async { implicit request =>
+  def get(id: String) = authenticated(Role.read).async { implicit request ⇒
     analyzerSrv.get(id.replaceAll("\\.", "_")) // FIXME replace "." by "_" should not be usefull after migration
-      .map(analyzer => renderer.toOutput(OK, analyzer))
+      .map(analyzer ⇒ renderer.toOutput(OK, analyzer))
   }
 
   @Timed
-  def find = authenticated(Role.read).async(fieldsBodyParser) { implicit request =>
+  def find = authenticated(Role.read).async(fieldsBodyParser) { implicit request ⇒
     val query = request.body.getValue("query").fold[QueryDef](QueryDSL.any)(_.as[QueryDef])
     val range = request.body.getString("range")
     val sort = request.body.getStrings("sort").getOrElse(Nil)
@@ -44,8 +44,8 @@ class AnalyzerCtrl @Inject() (
   }
 
   @Timed
-  def getReport(analyzerId: String, flavor: String) = authenticated(Role.read).async { request =>
+  def getReport(analyzerId: String, flavor: String) = authenticated(Role.read).async { request ⇒
     analyzerSrv.getReport(analyzerId.replaceAll("\\.", "_"), flavor) // FIXME replace "." by "_" should not be usefull after migration
-      .map { reportTemplate => Ok(reportTemplate) }
+      .map { reportTemplate ⇒ Ok(reportTemplate) }
   }
 }
diff --git a/thehive-backend/app/controllers/Artifact.scala b/thehive-backend/app/controllers/Artifact.scala
@@ -30,7 +30,7 @@ class ArtifactCtrl @Inject() (
     implicit val ec: ExecutionContext) extends Controller with Status {
 
   @Timed
-  def create(caseId: String) = authenticated(Role.write).async(fieldsBodyParser) { implicit request =>
+  def create(caseId: String) = authenticated(Role.write).async(fieldsBodyParser) { implicit request ⇒
     val fields = request.body
     val data = fields.getStrings("data")
       .getOrElse(fields.getString("data").toSeq)
@@ -39,46 +39,48 @@ class ArtifactCtrl @Inject() (
     // if data is not multivalued, use simple API (not bulk API)
     if (data.isEmpty) {
       artifactSrv.create(caseId, fields)
-        .map(artifact => renderer.toOutput(CREATED, artifact))
-    } else if (data.length == 1) {
+        .map(artifact ⇒ renderer.toOutput(CREATED, artifact))
+    }
+    else if (data.length == 1) {
       artifactSrv.create(caseId, fields.set("data", data.head))
-        .map(artifact => renderer.toOutput(CREATED, artifact))
-    } else {
+        .map(artifact ⇒ renderer.toOutput(CREATED, artifact))
+    }
+    else {
       val multiFields = data.map(fields.set("data", _))
       artifactSrv.create(caseId, multiFields)
-        .map(multiResult => renderer.toMultiOutput(CREATED, multiResult))
+        .map(multiResult ⇒ renderer.toMultiOutput(CREATED, multiResult))
     }
   }
 
   @Timed
-  def get(id: String) = authenticated(Role.read).async(fieldsBodyParser) { implicit request =>
+  def get(id: String) = authenticated(Role.read).async(fieldsBodyParser) { implicit request ⇒
     for {
-      artifact <- artifactSrv.get(id, request.body.getStrings("fields").map("dataType" +: _))
-      analyzers <- analyzerSrv.availableFor(artifact.dataType()).map(multiResult => Json.toJson(multiResult))
-    } yield renderer.toOutput(OK, Json.obj("artifact" -> artifact, "analyzers" -> analyzers))
+      artifact ← artifactSrv.get(id, request.body.getStrings("fields").map("dataType" +: _))
+      analyzers ← analyzerSrv.availableFor(artifact.dataType()).map(multiResult ⇒ Json.toJson(multiResult))
+    } yield renderer.toOutput(OK, Json.obj("artifact" → artifact, "analyzers" → analyzers))
   }
 
   @Timed
-  def update(id: String) = authenticated(Role.write).async(fieldsBodyParser) { implicit request =>
+  def update(id: String) = authenticated(Role.write).async(fieldsBodyParser) { implicit request ⇒
     artifactSrv.update(id, request.body)
-      .map(artifact => renderer.toOutput(OK, artifact))
+      .map(artifact ⇒ renderer.toOutput(OK, artifact))
   }
 
   @Timed
-  def bulkUpdate() = authenticated(Role.write).async(fieldsBodyParser) { implicit request =>
-    request.body.getStrings("ids").fold(Future.successful(Ok(JsArray()))) { ids =>
-      artifactSrv.bulkUpdate(ids, request.body.unset("ids")).map(multiResult => renderer.toMultiOutput(OK, multiResult))
+  def bulkUpdate() = authenticated(Role.write).async(fieldsBodyParser) { implicit request ⇒
+    request.body.getStrings("ids").fold(Future.successful(Ok(JsArray()))) { ids ⇒
+      artifactSrv.bulkUpdate(ids, request.body.unset("ids")).map(multiResult ⇒ renderer.toMultiOutput(OK, multiResult))
     }
   }
 
   @Timed
-  def delete(id: String) = authenticated(Role.write).async { implicit request =>
+  def delete(id: String) = authenticated(Role.write).async { implicit request ⇒
     artifactSrv.delete(id)
-      .map(_ => NoContent)
+      .map(_ ⇒ NoContent)
   }
 
   @Timed
-  def findInCase(caseId: String) = authenticated(Role.read).async(fieldsBodyParser) { implicit request =>
+  def findInCase(caseId: String) = authenticated(Role.read).async(fieldsBodyParser) { implicit request ⇒
     import org.elastic4play.services.QueryDSL._
     val childQuery = request.body.getValue("query").fold[QueryDef](QueryDSL.any)(_.as[QueryDef])
     val query = and(childQuery, "_parent" ~= caseId)
@@ -90,7 +92,7 @@ class ArtifactCtrl @Inject() (
   }
 
   @Timed
-  def find() = authenticated(Role.read).async(fieldsBodyParser) { implicit request =>
+  def find() = authenticated(Role.read).async(fieldsBodyParser) { implicit request ⇒
     val query = request.body.getValue("query").fold[QueryDef](QueryDSL.any)(_.as[QueryDef])
     val range = request.body.getString("range")
     val sort = request.body.getStrings("sort").getOrElse(Nil)
@@ -103,8 +105,8 @@ class ArtifactCtrl @Inject() (
   }
 
   @Timed
-  def findSimilar(artifactId: String) = authenticated(Role.read).async(fieldsBodyParser) { implicit request =>
-    artifactSrv.get(artifactId).flatMap { artifact =>
+  def findSimilar(artifactId: String) = authenticated(Role.read).async(fieldsBodyParser) { implicit request ⇒
+    artifactSrv.get(artifactId).flatMap { artifact ⇒
       val range = request.body.getString("range")
       val sort = request.body.getStrings("sort").getOrElse(Nil)
 
@@ -115,9 +117,9 @@ class ArtifactCtrl @Inject() (
   }
 
   @Timed
-  def stats() = authenticated(Role.read).async(fieldsBodyParser) { implicit request =>
+  def stats() = authenticated(Role.read).async(fieldsBodyParser) { implicit request ⇒
     val query = request.body.getValue("query").fold[QueryDef](QueryDSL.any)(_.as[QueryDef])
     val aggs = request.body.getValue("stats").getOrElse(throw BadRequestError("Parameter \"stats\" is missing")).as[Seq[Agg]]
-    artifactSrv.stats(query, aggs).map(s => Ok(s))
+    artifactSrv.stats(query, aggs).map(s ⇒ Ok(s))
   }
 }
diff --git a/thehive-backend/app/controllers/Asset.scala b/thehive-backend/app/controllers/Asset.scala
@@ -20,7 +20,8 @@ class AssetCtrlDev @Inject() (environment: Environment) extends ExternalAssets(e
   def get(file: String) = {
     if (file.startsWith("bower_components/")) {
       at("ui", file)
-    } else {
+    }
+    else {
       at("ui/app", file)
     }
   }

diff --git a/thehive-backend/app/controllers/Attachment.scala b/thehive-backend/app/controllers/Attachment.scala
@@ -20,16 +20,19 @@ import org.elastic4play.controllers.Renderer
  * Controller used to access stored attachments (plain or zipped)
  */
 @Singleton
-class AttachmentCtrl(password: String,
-                     attachmentSrv: AttachmentSrv,
-                     authenticated: Authenticated,
-                     renderer: Renderer) extends Controller {
+class AttachmentCtrl(
+    password: String,
+    attachmentSrv: AttachmentSrv,
+    authenticated: Authenticated,
+    renderer: Renderer) extends Controller {
 
-  @Inject() def this(configuration: Configuration,
-                     attachmentSrv: AttachmentSrv,
-                     authenticated: Authenticated,
-                     renderer: Renderer) =
-    this(configuration.getString("datastore.attachment.password").get,
+  @Inject() def this(
+    configuration: Configuration,
+    attachmentSrv: AttachmentSrv,
+    authenticated: Authenticated,
+    renderer: Renderer) =
+    this(
+      configuration.getString("datastore.attachment.password").get,
       attachmentSrv,
       authenticated,
       renderer)
@@ -40,7 +43,7 @@ class AttachmentCtrl(password: String,
    * open the document directly. It must be used only for safe file
    */
   @Timed("controllers.AttachmentCtrl.download")
-  def download(hash: String, name: Option[String]) = authenticated(Role.read) { implicit request =>
+  def download(hash: String, name: Option[String]) = authenticated(Role.read) { implicit request ⇒
     if (hash.startsWith("{{")) // angularjs hack
       NoContent
     else if (!name.getOrElse("").intersect(AttachmentAttributeFormat.forbiddenChar).isEmpty())
@@ -50,9 +53,9 @@ class AttachmentCtrl(password: String,
         header = ResponseHeader(
           200,
           Map(
-            "Content-Disposition" -> s"""attachment; filename="${name.getOrElse(hash)}"""",
-            "Content-Transfer-Encoding" -> "binary")),
-        body = HttpEntity.Streamed(attachmentSrv.source(hash), None, None))
+            "Content-Disposition" → s"""attachment; filename="${name.getOrElse(hash)}"""",
+            "Content-Transfer-Encoding" → "binary")),
+        body   = HttpEntity.Streamed(attachmentSrv.source(hash), None, None))
   }
 
   /**
@@ -61,7 +64,7 @@ class AttachmentCtrl(password: String,
    * File name can be specified (zip extension is append)
    */
   @Timed("controllers.AttachmentCtrl.downloadZip")
-  def downloadZip(hash: String, name: Option[String]) = authenticated(Role.read) { implicit request =>
+  def downloadZip(hash: String, name: Option[String]) = authenticated(Role.read) { implicit request ⇒
     if (!name.getOrElse("").intersect(AttachmentAttributeFormat.forbiddenChar).isEmpty())
       BadRequest("File name is invalid")
     else {
@@ -81,11 +84,11 @@ class AttachmentCtrl(password: String,
         header = ResponseHeader(
           200,
           Map(
-            "Content-Disposition" -> s"""attachment; filename="${name.getOrElse(hash)}.zip"""",
-            "Content-Type" -> "application/zip",
-            "Content-Transfer-Encoding" -> "binary",
-            "Content-Length" -> f.length.toString)),
-        body = HttpEntity.Streamed(FileIO.fromPath(f.toPath), Some(f.length), Some("application/zip")))
+            "Content-Disposition" → s"""attachment; filename="${name.getOrElse(hash)}.zip"""",
+            "Content-Type" → "application/zip",
+            "Content-Transfer-Encoding" → "binary",
+            "Content-Length" → f.length.toString)),
+        body   = HttpEntity.Streamed(FileIO.fromPath(f.toPath), Some(f.length), Some("application/zip")))
     }
   }
 }
diff --git a/thehive-backend/app/controllers/Authentication.scala b/thehive-backend/app/controllers/Authentication.scala
@@ -20,9 +20,9 @@ class AuthenticationCtrl @Inject() (
     implicit val ec: ExecutionContext) extends Controller {
 
   @Timed
-  def login = Action.async(fieldsBodyParser) { implicit request =>
+  def login = Action.async(fieldsBodyParser) { implicit request ⇒
     authSrv.authenticate(request.body.getString("user").getOrElse("TODO"), request.body.getString("password").getOrElse("TODO"))
-      .map { authContext => authenticated.setSessingUser(Ok, authContext) }
+      .map { authContext ⇒ authenticated.setSessingUser(Ok, authContext) }
   }
 
   @Timed

diff --git a/thehive-backend/app/controllers/Case.scala b/thehive-backend/app/controllers/Case.scala
@@ -50,8 +50,8 @@ class CaseCtrl @Inject() (
   @Timed
   def get(id: String) = authenticated(Role.read).async { implicit request ⇒
     val withStats = for {
-      statsValues <- request.queryString.get("nstats")
-      firstValue <- statsValues.headOption
+      statsValues ← request.queryString.get("nstats")
+      firstValue ← statsValues.headOption
     } yield Try(firstValue.toBoolean).getOrElse(firstValue == "1")
 
     for {
@@ -117,8 +117,8 @@ class CaseCtrl @Inject() (
         }.map {
           case (caze, artifacts) ⇒
             Json.toJson(caze).as[JsObject] - "description" +
-              ("linkedWith" -> Json.toJson(artifacts)) +
-              ("linksCount" -> Json.toJson(artifacts.size))
+              ("linkedWith" → Json.toJson(artifacts)) +
+              ("linksCount" → Json.toJson(artifacts.size))
         }
         renderer.toOutput(OK, casesList)
       }

diff --git a/thehive-backend/app/controllers/CaseTemplate.scala b/thehive-backend/app/controllers/CaseTemplate.scala
@@ -27,31 +27,31 @@ class CaseTemplateCtrl @Inject() (
     implicit val ec: ExecutionContext) extends Controller with Status {
 
   @Timed
-  def create = authenticated(Role.admin).async(fieldsBodyParser) { implicit request =>
+  def create = authenticated(Role.admin).async(fieldsBodyParser) { implicit request ⇒
     caseTemplateSrv.create(request.body)
-      .map(caze => renderer.toOutput(CREATED, caze))
+      .map(caze ⇒ renderer.toOutput(CREATED, caze))
   }
 
   @Timed
-  def get(id: String) = authenticated(Role.read).async { implicit request =>
+  def get(id: String) = authenticated(Role.read).async { implicit request ⇒
     caseTemplateSrv.get(id)
-      .map(caze => renderer.toOutput(OK, caze))
+      .map(caze ⇒ renderer.toOutput(OK, caze))
   }
 
   @Timed
-  def update(id: String) = authenticated(Role.admin).async(fieldsBodyParser) { implicit request =>
+  def update(id: String) = authenticated(Role.admin).async(fieldsBodyParser) { implicit request ⇒
     caseTemplateSrv.update(id, request.body)
-      .map(caze => renderer.toOutput(OK, caze))
+      .map(caze ⇒ renderer.toOutput(OK, caze))
   }
 
   @Timed
-  def delete(id: String) = authenticated(Role.admin).async { implicit request =>
+  def delete(id: String) = authenticated(Role.admin).async { implicit request ⇒
     caseTemplateSrv.delete(id)
-      .map(_ => NoContent)
+      .map(_ ⇒ NoContent)
   }
 
   @Timed
-  def find = authenticated(Role.read).async(fieldsBodyParser) { implicit request =>
+  def find = authenticated(Role.read).async(fieldsBodyParser) { implicit request ⇒
     val query = request.body.getValue("query").fold[QueryDef](QueryDSL.any)(_.as[QueryDef])
     val range = request.body.getString("range")
     val sort = request.body.getStrings("sort").getOrElse(Nil)

diff --git a/thehive-backend/app/controllers/Flow.scala b/thehive-backend/app/controllers/Flow.scala
@@ -26,7 +26,7 @@ class FlowCtrl @Inject() (
    * Return audit logs. For each item, include ancestor entities
    */
   @Timed
-  def flow(rootId: Option[String], count: Option[Int]) = authenticated(Role.read).async { implicit request =>
+  def flow(rootId: Option[String], count: Option[Int]) = authenticated(Role.read).async { implicit request ⇒
     val (audits, total) = flowSrv(rootId.filterNot(_ == "any"), count.getOrElse(10))
     renderer.toOutput(OK, audits, total)
   }

diff --git a/thehive-backend/app/controllers/Job.scala b/thehive-backend/app/controllers/Job.scala
@@ -26,19 +26,19 @@ class JobCtrl @Inject() (
     implicit val ec: ExecutionContext) extends Controller with Status {
 
   @Timed
-  def create(artifactId: String) = authenticated(Role.write).async(fieldsBodyParser) { implicit request =>
+  def create(artifactId: String) = authenticated(Role.write).async(fieldsBodyParser) { implicit request ⇒
     jobSrv.create(artifactId, request.body)
-      .map(job => renderer.toOutput(CREATED, job))
+      .map(job ⇒ renderer.toOutput(CREATED, job))
   }
 
   @Timed
-  def get(id: String) = authenticated(Role.read).async { implicit request =>
+  def get(id: String) = authenticated(Role.read).async { implicit request ⇒
     jobSrv.get(id)
-      .map(artifact => renderer.toOutput(OK, artifact))
+      .map(artifact ⇒ renderer.toOutput(OK, artifact))
   }
 
   @Timed
-  def findInArtifact(artifactId: String) = authenticated(Role.read).async(fieldsBodyParser) { implicit request =>
+  def findInArtifact(artifactId: String) = authenticated(Role.read).async(fieldsBodyParser) { implicit request ⇒
     import org.elastic4play.services.QueryDSL._
     val childQuery = request.body.getValue("query").fold[QueryDef](QueryDSL.any)(_.as[QueryDef])
     val query = and(childQuery, "_parent" ~= artifactId)
@@ -50,7 +50,7 @@ class JobCtrl @Inject() (
   }
 
   @Timed
-  def find = authenticated(Role.read).async(fieldsBodyParser) { implicit request =>
+  def find = authenticated(Role.read).async(fieldsBodyParser) { implicit request ⇒
     val query = request.body.getValue("query").fold[QueryDef](QueryDSL.any)(_.as[QueryDef])
     val range = request.body.getString("range")
     val sort = request.body.getStrings("sort").getOrElse(Nil)
@@ -60,9 +60,9 @@ class JobCtrl @Inject() (
   }
 
   @Timed
-  def stats() = authenticated(Role.read).async(fieldsBodyParser) { implicit request =>
+  def stats() = authenticated(Role.read).async(fieldsBodyParser) { implicit request ⇒
     val query = request.body.getValue("query").fold[QueryDef](QueryDSL.any)(_.as[QueryDef])
     val agg = request.body.getValue("stats").getOrElse(throw BadRequestError("Parameter \"stats\" is missing")).as[Agg]
-    jobSrv.stats(query, agg).map(s => Ok(s))
+    jobSrv.stats(query, agg).map(s ⇒ Ok(s))
   }
 }