From 91a4120b4253dc4a1e9552ec39fcb25c303a21e1 Mon Sep 17 00:00:00 2001
From: vlad <vlad@driver.xyz>
Date: Tue, 13 Jun 2017 16:15:07 -0700
Subject: Scalafmt

---
 src/main/scala/xyz/driver/pdsuicommon/Config.scala |  12 +-
 .../scala/xyz/driver/pdsuicommon/acl/ACL.scala     | 297 ++++++++++---------
 .../pdsuicommon/auth/AnonymousRequestContext.scala |   2 +-
 .../auth/AuthenticatedRequestContext.scala         |   6 +-
 .../xyz/driver/pdsuicommon/compat/EitherOps.scala  |   6 +-
 .../pdsuicommon/concurrent/BridgeUploadQueue.scala |   3 +-
 .../BridgeUploadQueueRepositoryAdapter.scala       |  18 +-
 .../xyz/driver/pdsuicommon/concurrent/Cron.scala   |   6 +-
 .../xyz/driver/pdsuicommon/db/DbCommand.scala      |   2 +-
 .../driver/pdsuicommon/db/DbCommandFactory.scala   |   4 +-
 .../pdsuicommon/db/EntityExtractorDerivation.scala |  22 +-
 .../pdsuicommon/db/EntityNotFoundException.scala   |   4 +-
 .../driver/pdsuicommon/db/MysqlQueryBuilder.scala  |  36 +--
 .../xyz/driver/pdsuicommon/db/QueryBuilder.scala   |  97 +++----
 .../driver/pdsuicommon/db/SearchFilterExpr.scala   |  31 +-
 .../scala/xyz/driver/pdsuicommon/db/Sorting.scala  |  15 +-
 .../xyz/driver/pdsuicommon/db/SqlContext.scala     |  48 +--
 .../repositories/BridgeUploadQueueRepository.scala |   2 +-
 .../xyz/driver/pdsuicommon/domain/FuzzyValue.scala |   4 +-
 .../driver/pdsuicommon/domain/PasswordHash.scala   |   2 +-
 .../scala/xyz/driver/pdsuicommon/domain/User.scala |  20 +-
 .../pdsuicommon/error/ExceptionFormatter.scala     |   2 +-
 .../pdsuicommon/http/AsyncHttpClientFetcher.scala  |  27 +-
 .../pdsuicommon/http/AsyncHttpClientUploader.scala |  22 +-
 .../pdsuicommon/logging/DefaultPhiLogger.scala     |   2 +-
 .../xyz/driver/pdsuicommon/logging/Implicits.scala |  14 +-
 .../xyz/driver/pdsuicommon/logging/Unsafe.scala    |   3 +-
 .../pdsuicommon/pdf/WkHtmlToPdfRenderer.scala      |  15 +-
 .../xyz/driver/pdsuicommon/utils/Computation.scala |  19 +-
 .../xyz/driver/pdsuicommon/utils/MapOps.scala      |   5 +-
 .../driver/pdsuicommon/utils/ServiceUtils.scala    |   2 +-
 .../scala/xyz/driver/pdsuicommon/utils/Utils.scala |   2 +-
 .../driver/pdsuicommon/validation/Validators.scala |   5 +-
 .../xyz/driver/pdsuidomain/entities/Arm.scala      |   3 +-
 .../driver/pdsuidomain/entities/DirectReport.scala |   6 +-
 .../xyz/driver/pdsuidomain/entities/Document.scala |  33 +--
 .../driver/pdsuidomain/entities/Hypothesis.scala   |   5 +-
 .../driver/pdsuidomain/entities/Intervention.scala |   1 -
 .../xyz/driver/pdsuidomain/entities/Label.scala    |   5 +-
 .../pdsuidomain/entities/MedicalRecord.scala       |  72 ++---
 .../xyz/driver/pdsuidomain/entities/Patient.scala  |  23 +-
 .../entities/PatientEligibleTrial.scala            |  37 +--
 .../xyz/driver/pdsuidomain/entities/Trial.scala    |  36 ++-
 .../export/patient/ExportPatientLabel.scala        |   4 +-
 .../export/patient/ExportPatientWithLabels.scala   |   3 +-
 .../export/trial/ExportTrialWithLabels.scala       |  25 +-
 .../pdsuidomain/services/CategoryService.scala     |   6 +-
 .../pdsuidomain/services/ExportService.scala       |  13 +-
 .../driver/pdsuidomain/services/LabelService.scala |   7 +-
 .../pdsuidomain/services/MessageService.scala      |  51 ++--
 .../driver/pdsuidomain/services/UserService.scala  |  68 ++---
 .../storage/MedicalRecordDocumentStorage.scala     |   3 +-
 .../pdsuidomain/storage/RequestStorage.scala       |  10 +-
 .../scala/xyz/driver/pdsuicommon/BaseSuite.scala   |   6 +-
 src/test/scala/xyz/driver/pdsuicommon/Mocks.scala  |  25 +-
 .../BridgeUploadQueueRepositoryAdapterSuite.scala  |  59 ++--
 .../db/QueryBuilderParametersSuite.scala           | 323 ++++++++++++---------
 .../pdsuicommon/db/SearchFilterExprSuite.scala     |  20 +-
 .../logging/PhiStringContextSuite.scala            |   2 +-
 .../xyz/driver/pdsuicommon/utils/DiffUtils.scala   |   4 +-
 .../xyz/driver/pdsuidomain/DocumentSuite.scala     |  21 +-
 61 files changed, 847 insertions(+), 779 deletions(-)

diff --git a/src/main/scala/xyz/driver/pdsuicommon/Config.scala b/src/main/scala/xyz/driver/pdsuicommon/Config.scala
index e55e521..25686b8 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/Config.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/Config.scala
@@ -10,12 +10,12 @@ object Config {
 
   def loadConfig[Config](implicit reader: ConfigReader[Config]): Try[Config] = pureconfig.loadConfig match {
     case Right(x) => Success(x)
-    case Left(e) => Failure(new RuntimeException(e.toString))
+    case Left(e)  => Failure(new RuntimeException(e.toString))
   }
 
-  def loadConfig[Config](namespace: String)
-                        (implicit reader: ConfigReader[Config]): Try[Config] = pureconfig.loadConfig(namespace) match {
-    case Right(x) => Success(x)
-    case Left(e) => Failure(new RuntimeException(e.toString))
-  }
+  def loadConfig[Config](namespace: String)(implicit reader: ConfigReader[Config]): Try[Config] =
+    pureconfig.loadConfig(namespace) match {
+      case Right(x) => Success(x)
+      case Left(e)  => Failure(new RuntimeException(e.toString))
+    }
 }
diff --git a/src/main/scala/xyz/driver/pdsuicommon/acl/ACL.scala b/src/main/scala/xyz/driver/pdsuicommon/acl/ACL.scala
index 0110f46..394e49f 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/acl/ACL.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/acl/ACL.scala
@@ -19,152 +19,175 @@ object ACL extends PhiLogging {
 
   // Common
 
-  object User extends BaseACL(
-    label = "user",
-    create = Set(RecordAdmin, TrialAdmin, TreatmentMatchingAdmin),
-    read = Allow,
-    update = Allow,
-    delete = Set(RecordAdmin, TrialAdmin, TreatmentMatchingAdmin)
-  )
-
-  object Label extends BaseACL(
-    label = "label",
-    read = RepRoles ++ TcRoles ++ TreatmentMatchingRoles
-  )
+  object User
+      extends BaseACL(
+        label = "user",
+        create = Set(RecordAdmin, TrialAdmin, TreatmentMatchingAdmin),
+        read = Allow,
+        update = Allow,
+        delete = Set(RecordAdmin, TrialAdmin, TreatmentMatchingAdmin)
+      )
+
+  object Label
+      extends BaseACL(
+        label = "label",
+        read = RepRoles ++ TcRoles ++ TreatmentMatchingRoles
+      )
 
   // REP
 
-  object MedicalRecord extends BaseACL(
-    label = "medical record",
-    read = RepRoles + RoutesCurator + TreatmentMatchingAdmin,
-    update = RepRoles - DocumentExtractor
-  )
-
-  object Document extends BaseACL(
-    label = "document",
-    create = Set(RecordOrganizer, RecordAdmin),
-    read = RepRoles - RecordCleaner + RoutesCurator + TreatmentMatchingAdmin,
-    update = RepRoles - RecordCleaner,
-    delete = Set(RecordOrganizer, RecordAdmin)
-  )
-
-  object ExtractedData extends BaseACL(
-    label = "extracted data",
-    create = Set(DocumentExtractor, RecordAdmin),
-    read = Set(DocumentExtractor, RecordAdmin, RoutesCurator, TreatmentMatchingAdmin),
-    update = Set(DocumentExtractor, RecordAdmin),
-    delete = Set(DocumentExtractor, RecordAdmin)
-  )
-
-  object Keyword extends BaseACL(
-    label = "keyword",
-    read = Set(DocumentExtractor, RecordAdmin)
-  )
-
-  object ProviderType extends BaseACL(
-    label = "provider type",
-    read = RepRoles + RoutesCurator + TreatmentMatchingAdmin
-  )
-
-  object DocumentType extends BaseACL(
-    label = "document type",
-    read = RepRoles + RoutesCurator + TreatmentMatchingAdmin
-  )
-
-  object Message extends BaseACL(
-    label = "message",
-    create = RepRoles ++ TreatmentMatchingRoles ++ TcRoles,
-    read = RepRoles ++ TreatmentMatchingRoles ++ TcRoles,
-    update = RepRoles ++ TreatmentMatchingRoles ++ TcRoles,
-    delete = RepRoles ++ TreatmentMatchingRoles ++ TcRoles
-  )
+  object MedicalRecord
+      extends BaseACL(
+        label = "medical record",
+        read = RepRoles + RoutesCurator + TreatmentMatchingAdmin,
+        update = RepRoles - DocumentExtractor
+      )
+
+  object Document
+      extends BaseACL(
+        label = "document",
+        create = Set(RecordOrganizer, RecordAdmin),
+        read = RepRoles - RecordCleaner + RoutesCurator + TreatmentMatchingAdmin,
+        update = RepRoles - RecordCleaner,
+        delete = Set(RecordOrganizer, RecordAdmin)
+      )
+
+  object ExtractedData
+      extends BaseACL(
+        label = "extracted data",
+        create = Set(DocumentExtractor, RecordAdmin),
+        read = Set(DocumentExtractor, RecordAdmin, RoutesCurator, TreatmentMatchingAdmin),
+        update = Set(DocumentExtractor, RecordAdmin),
+        delete = Set(DocumentExtractor, RecordAdmin)
+      )
+
+  object Keyword
+      extends BaseACL(
+        label = "keyword",
+        read = Set(DocumentExtractor, RecordAdmin)
+      )
+
+  object ProviderType
+      extends BaseACL(
+        label = "provider type",
+        read = RepRoles + RoutesCurator + TreatmentMatchingAdmin
+      )
+
+  object DocumentType
+      extends BaseACL(
+        label = "document type",
+        read = RepRoles + RoutesCurator + TreatmentMatchingAdmin
+      )
+
+  object Message
+      extends BaseACL(
+        label = "message",
+        create = RepRoles ++ TreatmentMatchingRoles ++ TcRoles,
+        read = RepRoles ++ TreatmentMatchingRoles ++ TcRoles,
+        update = RepRoles ++ TreatmentMatchingRoles ++ TcRoles,
+        delete = RepRoles ++ TreatmentMatchingRoles ++ TcRoles
+      )
 
   // TC
 
-  object Trial extends BaseACL(
-    label = "trial",
-    read = TcRoles + RoutesCurator + TreatmentMatchingAdmin,
-    update = TcRoles
-  )
-
-  object StudyDesign extends BaseACL(
-    label = "study design",
-    read = Set(TrialSummarizer, TrialAdmin)
-  )
-
-  object Hypothesis extends BaseACL(
-    label = "hypothesis",
-    read = Set(TrialSummarizer, TrialAdmin) ++ TreatmentMatchingRoles
-  )
-
-  object Criterion extends BaseACL(
-    label = "criterion",
-    create = Set(CriteriaCurator, TrialAdmin),
-    read = Set(CriteriaCurator, TrialAdmin, RoutesCurator, TreatmentMatchingAdmin),
-    update = Set(CriteriaCurator, TrialAdmin),
-    delete = Set(CriteriaCurator, TrialAdmin)
-  )
-
-  object Arm extends BaseACL(
-    label = "arm",
-    create = Set(TrialSummarizer, TrialAdmin),
-    read = TcRoles,
-    update = Set(TrialSummarizer, TrialAdmin),
-    delete = Set(TrialSummarizer, TrialAdmin)
-  )
-
-  object Category extends BaseACL(
-    label = "category",
-    read = Set(DocumentExtractor, RecordAdmin, CriteriaCurator, TrialAdmin)
-  )
-
-  object Intervention extends BaseACL(
-    label = "intervention",
-    read = Set(TrialSummarizer, TrialAdmin),
-    update = Set(TrialSummarizer, TrialAdmin)
-  )
-
-  object InterventionType extends BaseACL(
-    label = "intervention type",
-    read = Set(TrialSummarizer, TrialAdmin)
-  )
+  object Trial
+      extends BaseACL(
+        label = "trial",
+        read = TcRoles + RoutesCurator + TreatmentMatchingAdmin,
+        update = TcRoles
+      )
+
+  object StudyDesign
+      extends BaseACL(
+        label = "study design",
+        read = Set(TrialSummarizer, TrialAdmin)
+      )
+
+  object Hypothesis
+      extends BaseACL(
+        label = "hypothesis",
+        read = Set(TrialSummarizer, TrialAdmin) ++ TreatmentMatchingRoles
+      )
+
+  object Criterion
+      extends BaseACL(
+        label = "criterion",
+        create = Set(CriteriaCurator, TrialAdmin),
+        read = Set(CriteriaCurator, TrialAdmin, RoutesCurator, TreatmentMatchingAdmin),
+        update = Set(CriteriaCurator, TrialAdmin),
+        delete = Set(CriteriaCurator, TrialAdmin)
+      )
+
+  object Arm
+      extends BaseACL(
+        label = "arm",
+        create = Set(TrialSummarizer, TrialAdmin),
+        read = TcRoles,
+        update = Set(TrialSummarizer, TrialAdmin),
+        delete = Set(TrialSummarizer, TrialAdmin)
+      )
+
+  object Category
+      extends BaseACL(
+        label = "category",
+        read = Set(DocumentExtractor, RecordAdmin, CriteriaCurator, TrialAdmin)
+      )
+
+  object Intervention
+      extends BaseACL(
+        label = "intervention",
+        read = Set(TrialSummarizer, TrialAdmin),
+        update = Set(TrialSummarizer, TrialAdmin)
+      )
+
+  object InterventionType
+      extends BaseACL(
+        label = "intervention type",
+        read = Set(TrialSummarizer, TrialAdmin)
+      )
 
   // EV
 
-  object Patient extends BaseACL(
-    label = "patient",
-    read = TreatmentMatchingRoles,
-    update = TreatmentMatchingRoles
-  )
-
-  object PatientLabel extends BaseACL(
-    label = "patient label",
-    read = TreatmentMatchingRoles,
-    update = TreatmentMatchingRoles
-  )
-
-  object PatientCriterion extends BaseACL(
-    label = "patient criterion",
-    read = TreatmentMatchingRoles,
-    update = TreatmentMatchingRoles
-  )
-
-  object PatientLabelEvidence extends BaseACL(
-    label = "patient label evidence",
-    read = TreatmentMatchingRoles
-  )
-
-  object EligibleTrial extends BaseACL(
-    label = "eligible trial",
-    read = Set(RoutesCurator, TreatmentMatchingAdmin),
-    update = Set(RoutesCurator, TreatmentMatchingAdmin)
-  )
-
-  object PatientHypothesis extends BaseACL(
-    label = "patient hypothesis",
-    read = Set(RoutesCurator, TreatmentMatchingAdmin),
-    update = Set(RoutesCurator, TreatmentMatchingAdmin)
-  )
+  object Patient
+      extends BaseACL(
+        label = "patient",
+        read = TreatmentMatchingRoles,
+        update = TreatmentMatchingRoles
+      )
+
+  object PatientLabel
+      extends BaseACL(
+        label = "patient label",
+        read = TreatmentMatchingRoles,
+        update = TreatmentMatchingRoles
+      )
+
+  object PatientCriterion
+      extends BaseACL(
+        label = "patient criterion",
+        read = TreatmentMatchingRoles,
+        update = TreatmentMatchingRoles
+      )
+
+  object PatientLabelEvidence
+      extends BaseACL(
+        label = "patient label evidence",
+        read = TreatmentMatchingRoles
+      )
+
+  object EligibleTrial
+      extends BaseACL(
+        label = "eligible trial",
+        read = Set(RoutesCurator, TreatmentMatchingAdmin),
+        update = Set(RoutesCurator, TreatmentMatchingAdmin)
+      )
+
+  object PatientHypothesis
+      extends BaseACL(
+        label = "patient hypothesis",
+        read = Set(RoutesCurator, TreatmentMatchingAdmin),
+        update = Set(RoutesCurator, TreatmentMatchingAdmin)
+      )
 
   // Utility code
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/auth/AnonymousRequestContext.scala b/src/main/scala/xyz/driver/pdsuicommon/auth/AnonymousRequestContext.scala
index 7b223ef..c677ef8 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/auth/AnonymousRequestContext.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/auth/AnonymousRequestContext.scala
@@ -4,7 +4,7 @@ class AnonymousRequestContext(val requestId: RequestId) {
 
   override def equals(that: Any): Boolean = {
     that.getClass == classOf[AnonymousRequestContext] &&
-      that.asInstanceOf[AnonymousRequestContext].requestId == requestId
+    that.asInstanceOf[AnonymousRequestContext].requestId == requestId
   }
 
   override def hashCode(): Int = requestId.hashCode()
diff --git a/src/main/scala/xyz/driver/pdsuicommon/auth/AuthenticatedRequestContext.scala b/src/main/scala/xyz/driver/pdsuicommon/auth/AuthenticatedRequestContext.scala
index 0f5de30..a1f93cd 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/auth/AuthenticatedRequestContext.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/auth/AuthenticatedRequestContext.scala
@@ -3,8 +3,8 @@ package xyz.driver.pdsuicommon.auth
 import xyz.driver.pdsuicommon.logging._
 import xyz.driver.pdsuicommon.domain.User
 
-class AuthenticatedRequestContext(val executor: User,
-                                  override val requestId: RequestId) extends AnonymousRequestContext(requestId) {
+class AuthenticatedRequestContext(val executor: User, override val requestId: RequestId)
+    extends AnonymousRequestContext(requestId) {
 
   override def equals(that: Any): Boolean = {
     that.getClass == this.getClass && {
@@ -15,7 +15,7 @@ class AuthenticatedRequestContext(val executor: User,
 
   override def hashCode(): Int = {
     val initial = 37
-    val first = initial * 17 + executor.hashCode()
+    val first   = initial * 17 + executor.hashCode()
     first * 17 + requestId.hashCode()
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuicommon/compat/EitherOps.scala b/src/main/scala/xyz/driver/pdsuicommon/compat/EitherOps.scala
index 96fb0c3..d069f86 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/compat/EitherOps.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/compat/EitherOps.scala
@@ -2,10 +2,12 @@ package xyz.driver.pdsuicommon.compat
 
 final class EitherOps[A, B](val self: Either[A, B]) extends AnyVal {
 
-  def map[B2](f: B => B2): Either[A, B2] = flatMap { x => Right(f(x)) }
+  def map[B2](f: B => B2): Either[A, B2] = flatMap { x =>
+    Right(f(x))
+  }
 
   def flatMap[B2](f: B => Either[A, B2]): Either[A, B2] = self match {
-    case Left(x) => Left(x)
+    case Left(x)  => Left(x)
     case Right(x) => f(x)
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/concurrent/BridgeUploadQueue.scala b/src/main/scala/xyz/driver/pdsuicommon/concurrent/BridgeUploadQueue.scala
index 320666d..feb3774 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/concurrent/BridgeUploadQueue.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/concurrent/BridgeUploadQueue.scala
@@ -28,7 +28,8 @@ object BridgeUploadQueue {
                         dependencyTag: Option[String]) {
 
     def dependency: Option[Dependency] = {
-      dependencyKind.zip(dependencyTag)
+      dependencyKind
+        .zip(dependencyTag)
         .headOption
         .map(Function.tupled(Dependency.apply))
     }
diff --git a/src/main/scala/xyz/driver/pdsuicommon/concurrent/BridgeUploadQueueRepositoryAdapter.scala b/src/main/scala/xyz/driver/pdsuicommon/concurrent/BridgeUploadQueueRepositoryAdapter.scala
index 8c87b60..a98d2cd 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/concurrent/BridgeUploadQueueRepositoryAdapter.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/concurrent/BridgeUploadQueueRepositoryAdapter.scala
@@ -30,8 +30,9 @@ object BridgeUploadQueueRepositoryAdapter {
       */
     final case class LimitExponential(startInterval: FiniteDuration,
                                       intervalFactor: Double,
-                                        maxInterval: FiniteDuration,
-                                      onComplete: OnComplete) extends Strategy {
+                                      maxInterval: FiniteDuration,
+                                      onComplete: OnComplete)
+        extends Strategy {
 
       override def on(attempt: Int): OnAttempt = {
         OnAttempt.Continue(intervalFor(attempt).min(maxInterval))
@@ -67,14 +68,14 @@ object BridgeUploadQueueRepositoryAdapter {
     sealed trait OnComplete
     object OnComplete {
       case object Delete extends OnComplete
-      case object Mark extends OnComplete
+      case object Mark   extends OnComplete
 
       implicit def toPhiString(x: OnAttempt): PhiString = Unsafe(x.toString)
     }
 
     sealed trait OnAttempt
     object OnAttempt {
-      case object Complete extends OnAttempt
+      case object Complete                    extends OnAttempt
       case class Continue(interval: Duration) extends OnAttempt
 
       implicit def toPhiString(x: OnAttempt): PhiString = Unsafe(x.toString)
@@ -84,9 +85,8 @@ object BridgeUploadQueueRepositoryAdapter {
 
 class BridgeUploadQueueRepositoryAdapter(strategy: Strategy,
                                          repository: BridgeUploadQueueRepository,
-                                         transactions: Transactions)
-                                        (implicit executionContext: ExecutionContext)
-  extends BridgeUploadQueue with PhiLogging {
+                                         transactions: Transactions)(implicit executionContext: ExecutionContext)
+    extends BridgeUploadQueue with PhiLogging {
 
   override def add(item: Item): Future[Unit] = transactions.run { _ =>
     repository.add(item)
@@ -104,7 +104,7 @@ class BridgeUploadQueueRepositoryAdapter(strategy: Strategy,
       case Mark =>
         repository.getById(item) match {
           case Some(x) => repository.update(x.copy(completed = true))
-          case None => throw new RuntimeException(s"Can not find the $item task")
+          case None    => throw new RuntimeException(s"Can not find the $item task")
         }
     }
   }
@@ -115,7 +115,7 @@ class BridgeUploadQueueRepositoryAdapter(strategy: Strategy,
     logger.trace(phi"tryRetry($item)")
 
     val newAttempts = item.attempts + 1
-    val action = strategy.on(newAttempts)
+    val action      = strategy.on(newAttempts)
     logger.debug(phi"Action for ${Unsafe(newAttempts)}: $action")
 
     action match {
diff --git a/src/main/scala/xyz/driver/pdsuicommon/concurrent/Cron.scala b/src/main/scala/xyz/driver/pdsuicommon/concurrent/Cron.scala
index a6e9d2c..dd84beb 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/concurrent/Cron.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/concurrent/Cron.scala
@@ -62,10 +62,8 @@ object Cron {
 
   case class Settings(disable: String, intervals: Map[String, FiniteDuration])
 
-  private class SingletonTask(taskName: String,
-                              job: () => Future[Unit])
-                             (implicit ec: ExecutionContext)
-    extends TimerTask with StrictLogging {
+  private class SingletonTask(taskName: String, job: () => Future[Unit])(implicit ec: ExecutionContext)
+      extends TimerTask with StrictLogging {
 
     private val isWorking = new AtomicBoolean(false)
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/DbCommand.scala b/src/main/scala/xyz/driver/pdsuicommon/db/DbCommand.scala
index 911ecee..5dafc00 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/DbCommand.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/DbCommand.scala
@@ -9,7 +9,7 @@ trait DbCommand {
 
 object DbCommand {
   val Empty: DbCommand = new DbCommand {
-    override def runSync(): Unit = {}
+    override def runSync(): Unit                                    = {}
     override def runAsync(transactions: Transactions): Future[Unit] = Future.successful(())
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/DbCommandFactory.scala b/src/main/scala/xyz/driver/pdsuicommon/db/DbCommandFactory.scala
index f12b437..1e2fb74 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/DbCommandFactory.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/DbCommandFactory.scala
@@ -8,7 +8,7 @@ trait DbCommandFactory[T] {
 
 object DbCommandFactory {
   def empty[T]: DbCommandFactory[T] = new DbCommandFactory[T] {
-    override def createCommand(orig: T)(implicit ec: ExecutionContext): Future[DbCommand] = Future.successful(DbCommand.Empty)
+    override def createCommand(orig: T)(implicit ec: ExecutionContext): Future[DbCommand] =
+      Future.successful(DbCommand.Empty)
   }
 }
-
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/EntityExtractorDerivation.scala b/src/main/scala/xyz/driver/pdsuicommon/db/EntityExtractorDerivation.scala
index e13ea39..02ba322 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/EntityExtractorDerivation.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/EntityExtractorDerivation.scala
@@ -8,13 +8,12 @@ import io.getquill.dsl.EncodingDsl
 import scala.language.experimental.macros
 import scala.reflect.macros.blackbox
 
-trait EntityExtractorDerivation[Naming <: NamingStrategy] {
-  this: EncodingDsl =>
+trait EntityExtractorDerivation[Naming <: NamingStrategy] { this: EncodingDsl =>
 
-  /**
-    * Simple Quill extractor derivation for [[T]]
-    * Only case classes available. Type parameters is not supported
-    */
+  /*
+    Simple Quill extractor derivation for [[T]]
+    Only case classes available. Type parameters is not supported
+   */
   def entityExtractor[T]: (ResultSet => T) = macro EntityExtractorDerivation.impl[T]
 }
 
@@ -34,16 +33,16 @@ object EntityExtractorDerivation {
         case cons: MethodSymbol if cons.isConstructor =>
           // Create param list for constructor
           val params = cons.paramLists.flatten.map { param =>
-            val t = param.typeSignature
+            val t         = param.typeSignature
             val paramName = param.name.toString
-            val col = q"$namingStrategy.column($paramName)"
+            val col       = q"$namingStrategy.column($paramName)"
             // Resolve implicit decoders (from SqlContext) and apply ResultSet for each
             val d = q"implicitly[${c.prefix}.Decoder[$t]]"
             // Minus 1 cause Quill JDBC decoders make plus one.
             // ¯\_(ツ)_/¯
-            val i = q"row.findColumn($col) - 1"
+            val i           = q"row.findColumn($col) - 1"
             val decoderName = TermName(paramName + "Decoder")
-            val valueName = TermName(paramName + "Value")
+            val valueName   = TermName(paramName + "Value")
             (
               q"val $decoderName = $d",
               q"val $valueName = $decoderName($i, row)",
@@ -59,8 +58,7 @@ object EntityExtractorDerivation {
       }
       resultOpt match {
         case Some(result) => result
-        case None => c.abort(c.enclosingPosition,
-          s"Can not derive extractor for $tpe. Constructor not found.")
+        case None         => c.abort(c.enclosingPosition, s"Can not derive extractor for $tpe. Constructor not found.")
       }
     }
     q"(row: java.sql.ResultSet) => $functionBody"
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/EntityNotFoundException.scala b/src/main/scala/xyz/driver/pdsuicommon/db/EntityNotFoundException.scala
index 3b3bbdf..d779e10 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/EntityNotFoundException.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/EntityNotFoundException.scala
@@ -2,8 +2,8 @@ package xyz.driver.pdsuicommon.db
 
 import xyz.driver.pdsuicommon.domain.Id
 
-class EntityNotFoundException private(id: String, tableName: String)
-  extends RuntimeException(s"Entity with id $id is not found in $tableName table") {
+class EntityNotFoundException private (id: String, tableName: String)
+    extends RuntimeException(s"Entity with id $id is not found in $tableName table") {
 
   def this(id: Id[_], tableName: String) = this(id.toString, tableName)
   def this(id: Long, tableName: String) = this(id.toString, tableName)
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/MysqlQueryBuilder.scala b/src/main/scala/xyz/driver/pdsuicommon/db/MysqlQueryBuilder.scala
index 672a34e..6b7639a 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/MysqlQueryBuilder.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/MysqlQueryBuilder.scala
@@ -15,8 +15,7 @@ object MysqlQueryBuilder {
                nullableFields: Set[String],
                links: Set[TableLink],
                runner: Runner[T],
-               countRunner: CountRunner)
-              (implicit ec: ExecutionContext): MysqlQueryBuilder[T] = {
+               countRunner: CountRunner)(implicit ec: ExecutionContext): MysqlQueryBuilder[T] = {
     val parameters = MysqlQueryBuilderParameters(
       tableData = TableData(tableName, lastUpdateFieldName, nullableFields),
       links = links.map(x => x.foreignTableName -> x)(breakOut)
@@ -28,8 +27,7 @@ object MysqlQueryBuilder {
                lastUpdateFieldName: Option[String],
                nullableFields: Set[String],
                links: Set[TableLink],
-               extractor: (ResultSet) => T)
-              (implicit sqlContext: SqlContext): MysqlQueryBuilder[T] = {
+               extractor: (ResultSet) => T)(implicit sqlContext: SqlContext): MysqlQueryBuilder[T] = {
 
     val runner = (parameters: QueryBuilderParameters) => {
       Future {
@@ -43,14 +41,19 @@ object MysqlQueryBuilder {
     val countRunner = (parameters: QueryBuilderParameters) => {
       Future {
         val (sql, binder) = parameters.toSql(countQuery = true, namingStrategy = MysqlEscape)
-        sqlContext.executeQuery[CountResult](sql, binder, { resultSet =>
-          val count = resultSet.getInt(1)
-          val lastUpdate = if (parameters.tableData.lastUpdateFieldName.isDefined) {
-            Option(sqlContext.localDateTimeDecoder.decoder(2, resultSet))
-          } else None
-
-          (count, lastUpdate)
-        }).head
+        sqlContext
+          .executeQuery[CountResult](
+            sql,
+            binder, { resultSet =>
+              val count = resultSet.getInt(1)
+              val lastUpdate = if (parameters.tableData.lastUpdateFieldName.isDefined) {
+                Option(sqlContext.localDateTimeDecoder.decoder(2, resultSet))
+              } else None
+
+              (count, lastUpdate)
+            }
+          )
+          .head
       }(sqlContext.executionContext)
     }
 
@@ -65,11 +68,10 @@ object MysqlQueryBuilder {
   }
 }
 
-class MysqlQueryBuilder[T](parameters: MysqlQueryBuilderParameters)
-                          (implicit runner: QueryBuilder.Runner[T],
-                           countRunner: QueryBuilder.CountRunner,
-                           ec: ExecutionContext)
-  extends QueryBuilder[T, MySQLDialect, MysqlEscape](parameters) {
+class MysqlQueryBuilder[T](parameters: MysqlQueryBuilderParameters)(implicit runner: QueryBuilder.Runner[T],
+                                                                    countRunner: QueryBuilder.CountRunner,
+                                                                    ec: ExecutionContext)
+    extends QueryBuilder[T, MySQLDialect, MysqlEscape](parameters) {
 
   def withFilter(newFilter: SearchFilterExpr): QueryBuilder[T, MySQLDialect, MysqlEscape] = {
     new MysqlQueryBuilder[T](parameters.copy(filter = newFilter))
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/QueryBuilder.scala b/src/main/scala/xyz/driver/pdsuicommon/db/QueryBuilder.scala
index 9b798d8..733d355 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/QueryBuilder.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/QueryBuilder.scala
@@ -32,9 +32,7 @@ object QueryBuilder {
 
 }
 
-case class TableLink(keyColumnName: String,
-                     foreignTableName: String,
-                     foreignKeyColumnName: String)
+case class TableLink(keyColumnName: String, foreignTableName: String, foreignKeyColumnName: String)
 
 object QueryBuilderParameters {
   val AllFields = Set("*")
@@ -49,7 +47,7 @@ sealed trait QueryBuilderParameters {
   def pagination: Option[Pagination]
 
   def findLink(tableName: String): TableLink = links.get(tableName) match {
-    case None => throw new IllegalArgumentException(s"Cannot find a link for `$tableName`")
+    case None       => throw new IllegalArgumentException(s"Cannot find a link for `$tableName`")
     case Some(link) => link
   }
 
@@ -57,14 +55,12 @@ sealed trait QueryBuilderParameters {
     toSql(countQuery, QueryBuilderParameters.AllFields, namingStrategy)
   }
 
-  def toSql(countQuery: Boolean,
-            fields: Set[String],
-            namingStrategy: NamingStrategy): (String, QueryBuilder.Binder) = {
+  def toSql(countQuery: Boolean, fields: Set[String], namingStrategy: NamingStrategy): (String, QueryBuilder.Binder) = {
     val escapedTableName = namingStrategy.table(tableData.tableName)
     val fieldsSql: String = if (countQuery) {
       "count(*)" + (tableData.lastUpdateFieldName match {
         case Some(lastUpdateField) => s", max($escapedTableName.${namingStrategy.column(lastUpdateField)})"
-        case None => ""
+        case None                  => ""
       })
     } else {
       if (fields == QueryBuilderParameters.AllFields) {
@@ -78,7 +74,7 @@ sealed trait QueryBuilderParameters {
       }
     }
     val (where, bindings) = filterToSql(escapedTableName, filter, namingStrategy)
-    val orderBy = sortingToSql(escapedTableName, sorting, namingStrategy)
+    val orderBy           = sortingToSql(escapedTableName, sorting, namingStrategy)
 
     val limitSql = limitToSql()
 
@@ -92,9 +88,9 @@ sealed trait QueryBuilderParameters {
       import SearchFilterExpr._
       def aux(expr: SearchFilterExpr): Seq[TableLink] = expr match {
         case Atom.TableName(tableName) => List(findLink(tableName))
-        case Intersection(xs) => xs.flatMap(aux)
-        case Union(xs) => xs.flatMap(aux)
-        case _ => Nil
+        case Intersection(xs)          => xs.flatMap(aux)
+        case Union(xs)                 => xs.flatMap(aux)
+        case _                         => Nil
       }
       aux(filter)
     }
@@ -188,33 +184,35 @@ sealed trait QueryBuilderParameters {
         // So, to handle NotEq for nullable fields we need to use more complex SQL expression.
         // http://dev.mysql.com/doc/refman/5.7/en/working-with-null.html
         val escapedColumn = escapeDimension(dimension)
-        val sql = s"($escapedColumn is null or $escapedColumn != ${placeholder(dimension.name)})"
+        val sql           = s"($escapedColumn is null or $escapedColumn != ${placeholder(dimension.name)})"
         (sql, List(value))
 
       case Atom.Binary(dimension, op, value) =>
         val operator = op match {
-          case Eq => "="
+          case Eq    => "="
           case NotEq => "!="
-          case Like => "like"
-          case Gt => ">"
-          case GtEq => ">="
-          case Lt => "<"
-          case LtEq => "<="
+          case Like  => "like"
+          case Gt    => ">"
+          case GtEq  => ">="
+          case Lt    => "<"
+          case LtEq  => "<="
         }
         (s"${escapeDimension(dimension)} $operator ${placeholder(dimension.name)}", List(value))
 
       case Atom.NAry(dimension, op, values) =>
         val sqlOp = op match {
-          case SearchFilterNAryOperation.In => "in"
+          case SearchFilterNAryOperation.In    => "in"
           case SearchFilterNAryOperation.NotIn => "not in"
         }
 
-        val bindings = ListBuffer[AnyRef]()
+        val bindings       = ListBuffer[AnyRef]()
         val sqlPlaceholder = placeholder(dimension.name)
-        val formattedValues = values.map { value =>
-          bindings += value
-          sqlPlaceholder
-        }.mkString(", ")
+        val formattedValues = values
+          .map { value =>
+            bindings += value
+            sqlPlaceholder
+          }
+          .mkString(", ")
         (s"${escapeDimension(dimension)} $sqlOp ($formattedValues)", bindings.toList)
 
       case Intersection(operands) =>
@@ -232,13 +230,11 @@ sealed trait QueryBuilderParameters {
   /**
     * @param escapedMainTableName Should be escaped
     */
-  protected def sortingToSql(escapedMainTableName: String,
-                             sorting: Sorting,
-                             namingStrategy: NamingStrategy): String = {
+  protected def sortingToSql(escapedMainTableName: String, sorting: Sorting, namingStrategy: NamingStrategy): String = {
     sorting match {
       case Dimension(optSortingTableName, field, order) =>
         val sortingTableName = optSortingTableName.map(namingStrategy.table).getOrElse(escapedMainTableName)
-        val fullName = s"$sortingTableName.${namingStrategy.column(field)}"
+        val fullName         = s"$sortingTableName.${namingStrategy.column(field)}"
 
         s"$fullName ${orderToSql(order)}"
 
@@ -248,14 +244,14 @@ sealed trait QueryBuilderParameters {
   }
 
   protected def orderToSql(x: SortingOrder): String = x match {
-    case Ascending => "asc"
+    case Ascending  => "asc"
     case Descending => "desc"
   }
 
-  protected def binder(bindings: List[AnyRef])
-                      (bind: PreparedStatement): PreparedStatement = {
-    bindings.zipWithIndex.foreach { case (binding, index) =>
-      bind.setObject(index + 1, binding)
+  protected def binder(bindings: List[AnyRef])(bind: PreparedStatement): PreparedStatement = {
+    bindings.zipWithIndex.foreach {
+      case (binding, index) =>
+        bind.setObject(index + 1, binding)
     }
 
     bind
@@ -267,7 +263,8 @@ case class PostgresQueryBuilderParameters(tableData: QueryBuilder.TableData,
                                           links: Map[String, TableLink] = Map.empty,
                                           filter: SearchFilterExpr = SearchFilterExpr.Empty,
                                           sorting: Sorting = Sorting.Empty,
-                                          pagination: Option[Pagination] = None) extends QueryBuilderParameters {
+                                          pagination: Option[Pagination] = None)
+    extends QueryBuilderParameters {
 
   def limitToSql(): String = {
     pagination.map { pagination =>
@@ -285,19 +282,23 @@ case class MysqlQueryBuilderParameters(tableData: QueryBuilder.TableData,
                                        links: Map[String, TableLink] = Map.empty,
                                        filter: SearchFilterExpr = SearchFilterExpr.Empty,
                                        sorting: Sorting = Sorting.Empty,
-                                       pagination: Option[Pagination] = None) extends QueryBuilderParameters {
-
-  def limitToSql(): String = pagination.map { pagination =>
-    val startFrom = (pagination.pageNumber - 1) * pagination.pageSize
-    s"limit $startFrom, ${pagination.pageSize}"
-  }.getOrElse("")
+                                       pagination: Option[Pagination] = None)
+    extends QueryBuilderParameters {
+
+  def limitToSql(): String =
+    pagination
+      .map { pagination =>
+        val startFrom = (pagination.pageNumber - 1) * pagination.pageSize
+        s"limit $startFrom, ${pagination.pageSize}"
+      }
+      .getOrElse("")
 
 }
 
-abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameters: QueryBuilderParameters)
-                                                                  (implicit runner: QueryBuilder.Runner[T],
-                                                                   countRunner: QueryBuilder.CountRunner,
-                                                                   ec: ExecutionContext) {
+abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameters: QueryBuilderParameters)(
+        implicit runner: QueryBuilder.Runner[T],
+        countRunner: QueryBuilder.CountRunner,
+        ec: ExecutionContext) {
 
   def run: Future[Seq[T]] = runner(parameters)
 
@@ -307,11 +308,11 @@ abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameter
     * Runs the query and returns total found rows without considering of pagination.
     */
   def runWithCount: Future[(Seq[T], Int, Option[LocalDateTime])] = {
-    val countFuture = runCount
+    val countFuture     = runCount
     val selectAllFuture = run
     for {
       (total, lastUpdate) <- countFuture
-      all <- selectAllFuture
+      all                 <- selectAllFuture
     } yield (all, total, lastUpdate)
   }
 
@@ -323,7 +324,6 @@ abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameter
 
   def resetFilter: QueryBuilder[T, D, N] = withFilter(SearchFilterExpr.Empty)
 
-
   def withSorting(newSorting: Sorting): QueryBuilder[T, D, N]
 
   def withSorting(sorting: Option[Sorting]): QueryBuilder[T, D, N] = {
@@ -332,7 +332,6 @@ abstract class QueryBuilder[T, D <: SqlIdiom, N <: NamingStrategy](val parameter
 
   def resetSorting: QueryBuilder[T, D, N] = withSorting(Sorting.Empty)
 
-
   def withPagination(newPagination: Pagination): QueryBuilder[T, D, N]
 
   def withPagination(pagination: Option[Pagination]): QueryBuilder[T, D, N] = {
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/SearchFilterExpr.scala b/src/main/scala/xyz/driver/pdsuicommon/db/SearchFilterExpr.scala
index 60db303..5144163 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/SearchFilterExpr.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/SearchFilterExpr.scala
@@ -49,13 +49,13 @@ object SearchFilterExpr {
     object TableName {
       def unapply(value: Atom): Option[String] = value match {
         case Binary(Dimension(tableNameOpt, _), _, _) => tableNameOpt
-        case NAry(Dimension(tableNameOpt, _), _, _) => tableNameOpt
+        case NAry(Dimension(tableNameOpt, _), _, _)   => tableNameOpt
       }
     }
   }
 
-  case class Intersection private(operands: Seq[SearchFilterExpr])
-    extends SearchFilterExpr with SearchFilterExprSeqOps {
+  case class Intersection private (operands: Seq[SearchFilterExpr])
+      extends SearchFilterExpr with SearchFilterExprSeqOps {
 
     override def replace(f: PartialFunction[SearchFilterExpr, SearchFilterExpr]): SearchFilterExpr = {
       if (f.isDefinedAt(this)) f(this)
@@ -80,8 +80,7 @@ object SearchFilterExpr {
     }
   }
 
-
-  case class Union private(operands: Seq[SearchFilterExpr]) extends SearchFilterExpr with SearchFilterExprSeqOps {
+  case class Union private (operands: Seq[SearchFilterExpr]) extends SearchFilterExpr with SearchFilterExprSeqOps {
 
     override def replace(f: PartialFunction[SearchFilterExpr, SearchFilterExpr]): SearchFilterExpr = {
       if (f.isDefinedAt(this)) f(this)
@@ -123,14 +122,13 @@ object SearchFilterExpr {
 
     /** Create SearchFilterExpr with empty tableName */
     def create(field: String, values: String*): SearchFilterExpr =
-      create(Dimension(None, field), values:_*)
+      create(Dimension(None, field), values: _*)
 
     /** Create SearchFilterExpr with empty tableName */
     def create(field: String, values: Set[String]): SearchFilterExpr =
       create(Dimension(None, field), values)
   }
 
-
   case object AllowAll extends SearchFilterExpr {
     override def find(p: SearchFilterExpr => Boolean): Option[SearchFilterExpr] = {
       if (p(this)) Some(this)
@@ -159,8 +157,7 @@ object SearchFilterExpr {
     expr == Intersection.Empty || expr == Union.Empty
   }
 
-  sealed trait SearchFilterExprSeqOps {
-    this: SearchFilterExpr =>
+  sealed trait SearchFilterExprSeqOps { this: SearchFilterExpr =>
 
     val operands: Seq[SearchFilterExpr]
 
@@ -171,7 +168,7 @@ object SearchFilterExpr {
         // Is's ok to use foldLeft. If there will be performance issues, replace it by recursive loop
         operands.foldLeft(Option.empty[SearchFilterExpr]) {
           case (None, expr) => expr.find(p)
-          case (x, _) => x
+          case (x, _)       => x
         }
       }
     }
@@ -190,13 +187,13 @@ sealed trait SearchFilterBinaryOperation
 
 object SearchFilterBinaryOperation {
 
-  case object Eq extends SearchFilterBinaryOperation
+  case object Eq    extends SearchFilterBinaryOperation
   case object NotEq extends SearchFilterBinaryOperation
-  case object Like extends SearchFilterBinaryOperation
-  case object Gt extends SearchFilterBinaryOperation
-  case object GtEq extends SearchFilterBinaryOperation
-  case object Lt extends SearchFilterBinaryOperation
-  case object LtEq extends SearchFilterBinaryOperation
+  case object Like  extends SearchFilterBinaryOperation
+  case object Gt    extends SearchFilterBinaryOperation
+  case object GtEq  extends SearchFilterBinaryOperation
+  case object Lt    extends SearchFilterBinaryOperation
+  case object LtEq  extends SearchFilterBinaryOperation
 
 }
 
@@ -204,7 +201,7 @@ sealed trait SearchFilterNAryOperation
 
 object SearchFilterNAryOperation {
 
-  case object In extends SearchFilterNAryOperation
+  case object In    extends SearchFilterNAryOperation
   case object NotIn extends SearchFilterNAryOperation
 
 }
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala b/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala
index 4b2427c..b796b83 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala
@@ -7,7 +7,7 @@ import scala.collection.generic.CanBuildFrom
 sealed trait SortingOrder
 object SortingOrder {
 
-  case object Ascending extends SortingOrder
+  case object Ascending  extends SortingOrder
   case object Descending extends SortingOrder
 
 }
@@ -34,25 +34,24 @@ object Sorting {
   def isEmpty(input: Sorting): Boolean = {
     input match {
       case Sequential(Seq()) => true
-      case _ => false
+      case _                 => false
     }
   }
 
   def filter(sorting: Sorting, p: Dimension => Boolean): Seq[Dimension] = sorting match {
     case x: Dimension if p(x) => Seq(x)
-    case x: Dimension => Seq.empty
-    case Sequential(xs) => xs.filter(p)
+    case x: Dimension         => Seq.empty
+    case Sequential(xs)       => xs.filter(p)
   }
 
-  def collect[B, That](sorting: Sorting)
-                      (f: PartialFunction[Dimension, B])
-                      (implicit bf: CanBuildFrom[Seq[Dimension], B, That]): That = sorting match {
+  def collect[B, That](sorting: Sorting)(f: PartialFunction[Dimension, B])(
+          implicit bf: CanBuildFrom[Seq[Dimension], B, That]): That = sorting match {
     case x: Dimension if f.isDefinedAt(x) =>
       val r = bf.apply()
       r += f(x)
       r.result()
 
-    case x: Dimension => bf.apply().result()
+    case x: Dimension   => bf.apply().result()
     case Sequential(xs) => xs.collect(f)
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/SqlContext.scala b/src/main/scala/xyz/driver/pdsuicommon/db/SqlContext.scala
index 5aa0084..7477e71 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/SqlContext.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/SqlContext.scala
@@ -51,8 +51,7 @@ object SqlContext extends PhiLogging {
 }
 
 class SqlContext(dataSource: DataSource with Closeable, settings: Settings)
-  extends MysqlJdbcContext[MysqlEscape](dataSource)
-    with EntityExtractorDerivation[Literal] {
+    extends MysqlJdbcContext[MysqlEscape](dataSource) with EntityExtractorDerivation[Literal] {
 
   private val tpe = Executors.newFixedThreadPool(settings.threadPoolSize)
 
@@ -77,31 +76,31 @@ class SqlContext(dataSource: DataSource with Closeable, settings: Settings)
   implicit override def optionDecoder[T](implicit d: Decoder[T]): Decoder[Option[T]] =
     decoder(
       sqlType = d.sqlType,
-      row => index => {
-        try {
-          val res = d(index - 1, row)
-          if (row.wasNull) {
-            None
+      row =>
+        index => {
+          try {
+            val res = d(index - 1, row)
+            if (row.wasNull) {
+              None
+            } else {
+              Some(res)
+            }
+          } catch {
+            case _: NullPointerException => None
+            case _: IncorrectIdException => None
           }
-          else {
-            Some(res)
-          }
-        } catch {
-          case _: NullPointerException => None
-          case _: IncorrectIdException => None
-        }
       }
     )
 
   implicit def encodeStringId[T] = MappedEncoding[StringId[T], String](_.id)
   implicit def decodeStringId[T] = MappedEncoding[String, StringId[T]] {
     case "" => throw IncorrectIdException("'' is an invalid Id value")
-    case x => StringId(x)
+    case x  => StringId(x)
   }
 
   def decodeOptStringId[T] = MappedEncoding[Option[String], Option[StringId[T]]] {
     case None | Some("") => None
-    case Some(x) => Some(StringId(x))
+    case Some(x)         => Some(StringId(x))
   }
 
   implicit def encodeLongId[T] = MappedEncoding[LongId[T], Long](_.id)
@@ -113,21 +112,22 @@ class SqlContext(dataSource: DataSource with Closeable, settings: Settings)
   // TODO Dirty hack, see REP-475
   def decodeOptLongId[T] = MappedEncoding[Option[Long], Option[LongId[T]]] {
     case None | Some(0) => None
-    case Some(x) => Some(LongId(x))
+    case Some(x)        => Some(LongId(x))
   }
 
   implicit def encodeUuidId[T] = MappedEncoding[UuidId[T], String](_.toString)
   implicit def decodeUuidId[T] = MappedEncoding[String, UuidId[T]] {
     case "" => throw IncorrectIdException("'' is an invalid Id value")
-    case x => UuidId(x)
+    case x  => UuidId(x)
   }
 
   def decodeOptUuidId[T] = MappedEncoding[Option[String], Option[UuidId[T]]] {
     case None | Some("") => None
-    case Some(x) => Some(UuidId(x))
+    case Some(x)         => Some(UuidId(x))
   }
 
-  implicit def encodeTextJson[T: Manifest] = MappedEncoding[TextJson[T], String](x => JsonSerializer.serialize(x.content))
+  implicit def encodeTextJson[T: Manifest] =
+    MappedEncoding[TextJson[T], String](x => JsonSerializer.serialize(x.content))
   implicit def decodeTextJson[T: Manifest] = MappedEncoding[String, TextJson[T]] { x =>
     TextJson(JsonSerializer.deserialize[T](x))
   }
@@ -153,14 +153,14 @@ class SqlContext(dataSource: DataSource with Closeable, settings: Settings)
 
   implicit val encodeFuzzyValue = {
     MappedEncoding[FuzzyValue, String] {
-      case FuzzyValue.No => "No"
-      case FuzzyValue.Yes => "Yes"
+      case FuzzyValue.No    => "No"
+      case FuzzyValue.Yes   => "Yes"
       case FuzzyValue.Maybe => "Maybe"
     }
   }
   implicit val decodeFuzzyValue = MappedEncoding[String, FuzzyValue] {
-    case "Yes" => FuzzyValue.Yes
-    case "No" => FuzzyValue.No
+    case "Yes"   => FuzzyValue.Yes
+    case "No"    => FuzzyValue.No
     case "Maybe" => FuzzyValue.Maybe
     case x =>
       Option(x).fold {
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/repositories/BridgeUploadQueueRepository.scala b/src/main/scala/xyz/driver/pdsuicommon/db/repositories/BridgeUploadQueueRepository.scala
index edef2eb..a3140a6 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/repositories/BridgeUploadQueueRepository.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/repositories/BridgeUploadQueueRepository.scala
@@ -8,7 +8,7 @@ import scala.concurrent.Future
 trait BridgeUploadQueueRepository extends Repository {
 
   type EntityT = BridgeUploadQueue.Item
-  type IdT = LongId[EntityT]
+  type IdT     = LongId[EntityT]
 
   def add(draft: EntityT): EntityT
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/domain/FuzzyValue.scala b/src/main/scala/xyz/driver/pdsuicommon/domain/FuzzyValue.scala
index e338b2e..4c6bf3f 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/domain/FuzzyValue.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/domain/FuzzyValue.scala
@@ -6,8 +6,8 @@ import xyz.driver.pdsuicommon.utils.Utils
 sealed trait FuzzyValue
 
 object FuzzyValue {
-  case object Yes extends FuzzyValue
-  case object No extends FuzzyValue
+  case object Yes   extends FuzzyValue
+  case object No    extends FuzzyValue
   case object Maybe extends FuzzyValue
 
   val All: Set[FuzzyValue] = Set(Yes, No, Maybe)
diff --git a/src/main/scala/xyz/driver/pdsuicommon/domain/PasswordHash.scala b/src/main/scala/xyz/driver/pdsuicommon/domain/PasswordHash.scala
index 82cba8d..337d925 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/domain/PasswordHash.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/domain/PasswordHash.scala
@@ -15,7 +15,7 @@ final case class PasswordHash(value: Array[Byte]) {
   override def equals(that: Any): Boolean = {
     that match {
       case thatHash: PasswordHash => java.util.Arrays.equals(this.value, thatHash.value)
-      case _ => false
+      case _                      => false
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/domain/User.scala b/src/main/scala/xyz/driver/pdsuicommon/domain/User.scala
index acc3565..45adefc 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/domain/User.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/domain/User.scala
@@ -31,16 +31,16 @@ object User {
   }
 
   object Role extends PhiLogging {
-    case object RecordAdmin extends Role {val bit = 1 << 0}
-    case object RecordCleaner extends Role {val bit = 1 << 1}
-    case object RecordOrganizer extends Role {val bit = 1 << 2}
-    case object DocumentExtractor extends Role {val bit = 1 << 3}
-    case object TrialSummarizer extends Role {val bit = 1 << 4}
-    case object CriteriaCurator extends Role {val bit = 1 << 5}
-    case object TrialAdmin extends Role {val bit = 1 << 6}
-    case object EligibilityVerifier extends Role{val bit = 1 << 7}
-    case object TreatmentMatchingAdmin extends Role{val bit = 1 << 8}
-    case object RoutesCurator extends Role{val bit = 1 << 9}
+    case object RecordAdmin            extends Role { val bit = 1 << 0 }
+    case object RecordCleaner          extends Role { val bit = 1 << 1 }
+    case object RecordOrganizer        extends Role { val bit = 1 << 2 }
+    case object DocumentExtractor      extends Role { val bit = 1 << 3 }
+    case object TrialSummarizer        extends Role { val bit = 1 << 4 }
+    case object CriteriaCurator        extends Role { val bit = 1 << 5 }
+    case object TrialAdmin             extends Role { val bit = 1 << 6 }
+    case object EligibilityVerifier    extends Role { val bit = 1 << 7 }
+    case object TreatmentMatchingAdmin extends Role { val bit = 1 << 8 }
+    case object RoutesCurator          extends Role { val bit = 1 << 9 }
 
     val RepRoles = Set[Role](RecordAdmin, RecordCleaner, RecordOrganizer, DocumentExtractor)
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/error/ExceptionFormatter.scala b/src/main/scala/xyz/driver/pdsuicommon/error/ExceptionFormatter.scala
index 1e3e4c4..c9578b3 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/error/ExceptionFormatter.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/error/ExceptionFormatter.scala
@@ -8,7 +8,7 @@ object ExceptionFormatter {
 
   def printStackTrace(e: Throwable): String = {
     val baos = new ByteArrayOutputStream()
-    val ps = new PrintStream(baos)
+    val ps   = new PrintStream(baos)
 
     e.printStackTrace(ps)
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/http/AsyncHttpClientFetcher.scala b/src/main/scala/xyz/driver/pdsuicommon/http/AsyncHttpClientFetcher.scala
index 4b0d897..d693019 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/http/AsyncHttpClientFetcher.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/http/AsyncHttpClientFetcher.scala
@@ -14,7 +14,7 @@ import scala.concurrent.duration.FiniteDuration
 import scala.concurrent.{ExecutionContext, Future, Promise}
 
 class AsyncHttpClientFetcher(settings: AsyncHttpClientFetcher.Settings)
-  extends HttpFetcher with Closeable with StrictLogging {
+    extends HttpFetcher with Closeable with StrictLogging {
 
   private val es: ExecutorService = {
     val threadFactory = MdcThreadFactory.from(Executors.defaultThreadFactory())
@@ -40,17 +40,19 @@ class AsyncHttpClientFetcher(settings: AsyncHttpClientFetcher.Settings)
     logger.info("{}, apply({})", fingerPrint, url)
     val promise = Promise[Response]()
 
-    httpClient.prepareGet(url.toString).execute(new AsyncCompletionHandler[Response] {
-      override def onCompleted(response: Response): Response = {
-        promise.success(response)
-        response
-      }
+    httpClient
+      .prepareGet(url.toString)
+      .execute(new AsyncCompletionHandler[Response] {
+        override def onCompleted(response: Response): Response = {
+          promise.success(response)
+          response
+        }
 
-      override def onThrowable(t: Throwable): Unit = {
-        promise.failure(t)
-        super.onThrowable(t)
-      }
-    })
+        override def onThrowable(t: Throwable): Unit = {
+          promise.failure(t)
+          super.onThrowable(t)
+        }
+      })
 
     // Promises have their own ExecutionContext
     // So, we have to hack it.
@@ -84,7 +86,6 @@ class AsyncHttpClientFetcher(settings: AsyncHttpClientFetcher.Settings)
 
 object AsyncHttpClientFetcher {
 
-  case class Settings(connectTimeout: FiniteDuration,
-                      readTimeout: FiniteDuration)
+  case class Settings(connectTimeout: FiniteDuration, readTimeout: FiniteDuration)
 
 }
diff --git a/src/main/scala/xyz/driver/pdsuicommon/http/AsyncHttpClientUploader.scala b/src/main/scala/xyz/driver/pdsuicommon/http/AsyncHttpClientUploader.scala
index 6ad404f..d7bc3d3 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/http/AsyncHttpClientUploader.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/http/AsyncHttpClientUploader.scala
@@ -50,16 +50,18 @@ class AsyncHttpClientUploader(settings: Settings) extends Closeable with StrictL
 
     q.addHeader("Content-Type", contentType)
 
-    httpClient.prepareRequest(q).execute(new AsyncCompletionHandler[Unit] {
-      override def onCompleted(response: Response): Unit = {
-        promise.success(response)
-      }
-
-      override def onThrowable(t: Throwable): Unit = {
-        promise.failure(t)
-        super.onThrowable(t)
-      }
-    })
+    httpClient
+      .prepareRequest(q)
+      .execute(new AsyncCompletionHandler[Unit] {
+        override def onCompleted(response: Response): Unit = {
+          promise.success(response)
+        }
+
+        override def onThrowable(t: Throwable): Unit = {
+          promise.failure(t)
+          super.onThrowable(t)
+        }
+      })
 
     // see AsyncHttpClientFetcher
     val parentMdcContext = MDC.getCopyOfContextMap
diff --git a/src/main/scala/xyz/driver/pdsuicommon/logging/DefaultPhiLogger.scala b/src/main/scala/xyz/driver/pdsuicommon/logging/DefaultPhiLogger.scala
index 3b0c1ad..045f37a 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/logging/DefaultPhiLogger.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/logging/DefaultPhiLogger.scala
@@ -2,7 +2,7 @@ package xyz.driver.pdsuicommon.logging
 
 import org.slf4j.{Logger => Underlying}
 
-class DefaultPhiLogger private[logging](underlying: Underlying) extends PhiLogger {
+class DefaultPhiLogger private[logging] (underlying: Underlying) extends PhiLogger {
 
   def error(message: PhiString): Unit = underlying.error(message.text)
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/logging/Implicits.scala b/src/main/scala/xyz/driver/pdsuicommon/logging/Implicits.scala
index cf095e3..84cf31e 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/logging/Implicits.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/logging/Implicits.scala
@@ -33,21 +33,19 @@ trait Implicits {
 
   implicit def uuidToPhiString(x: UUID): PhiString = Unsafe(x.toString)
 
-  implicit def tuple2ToPhiString[T1, T2](x: (T1, T2))
-                                        (implicit inner1: T1 => PhiString,
-                                         inner2: T2 => PhiString): PhiString = x match {
+  implicit def tuple2ToPhiString[T1, T2](x: (T1, T2))(implicit inner1: T1 => PhiString,
+                                                      inner2: T2 => PhiString): PhiString = x match {
     case (a, b) => phi"($a, $b)"
   }
 
-  implicit def tuple3ToPhiString[T1, T2, T3](x: (T1, T2, T3))
-                                            (implicit inner1: T1 => PhiString,
-                                             inner2: T2 => PhiString,
-                                             inner3: T3 => PhiString): PhiString = x match {
+  implicit def tuple3ToPhiString[T1, T2, T3](x: (T1, T2, T3))(implicit inner1: T1 => PhiString,
+                                                              inner2: T2 => PhiString,
+                                                              inner3: T3 => PhiString): PhiString = x match {
     case (a, b, c) => phi"($a, $b, $c)"
   }
 
   implicit def optionToPhiString[T](opt: Option[T])(implicit inner: T => PhiString): PhiString = opt match {
-    case None => phi"None"
+    case None    => phi"None"
     case Some(x) => phi"Some($x)"
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/logging/Unsafe.scala b/src/main/scala/xyz/driver/pdsuicommon/logging/Unsafe.scala
index 3b0acb0..7fd810f 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/logging/Unsafe.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/logging/Unsafe.scala
@@ -3,4 +3,5 @@ package xyz.driver.pdsuicommon.logging
 /**
   * Use it with care!
   */
-case class Unsafe[T](private[logging] val value: T) extends PhiString(Option(value).map(_.toString).getOrElse("<null>"))
+case class Unsafe[T](private[logging] val value: T)
+    extends PhiString(Option(value).map(_.toString).getOrElse("<null>"))
diff --git a/src/main/scala/xyz/driver/pdsuicommon/pdf/WkHtmlToPdfRenderer.scala b/src/main/scala/xyz/driver/pdsuicommon/pdf/WkHtmlToPdfRenderer.scala
index 9c14646..8141b7f 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/pdf/WkHtmlToPdfRenderer.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/pdf/WkHtmlToPdfRenderer.scala
@@ -14,11 +14,12 @@ object WkHtmlToPdfRenderer {
     lazy val downloadsPath: Path = getPathFrom(downloadsDir)
 
     private def getPathFrom(x: String): Path = {
-      val dirPath = if (x.startsWith("/")) Paths.get(x)
-      else {
-        val workingDir = Paths.get(".")
-        workingDir.resolve(x)
-      }
+      val dirPath =
+        if (x.startsWith("/")) Paths.get(x)
+        else {
+          val workingDir = Paths.get(".")
+          workingDir.resolve(x)
+        }
 
       dirPath.toAbsolutePath.normalize()
     }
@@ -82,12 +83,12 @@ class WkHtmlToPdfRenderer(settings: Settings) extends PdfRenderer with PhiLoggin
   protected def forceCreate[SourceT: SourceDocumentLike](src: SourceT, dest: Path): Path = {
     logger.trace(phi"forceCreate[${Unsafe(src.getClass.getName)}](dest=$dest)")
 
-    val destTemp = Files.createTempFile("driver", ".pdf")
+    val destTemp     = Files.createTempFile("driver", ".pdf")
     val destTempFile = destTemp.toFile
 
     Files.createDirectories(dest.getParent)
 
-    val retCode = pdf.run(src, destTempFile)
+    val retCode      = pdf.run(src, destTempFile)
     lazy val pdfSize = destTempFile.length()
     if (retCode != 0) {
       // Try to google "wkhtmltopdf returns {retCode}"
diff --git a/src/main/scala/xyz/driver/pdsuicommon/utils/Computation.scala b/src/main/scala/xyz/driver/pdsuicommon/utils/Computation.scala
index e609ab0..9e6f3bd 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/utils/Computation.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/utils/Computation.scala
@@ -46,17 +46,16 @@ final case class Computation[+R, +T](future: Future[Either[R, T]]) {
 
   def flatMap[R2, T2](f: T => Computation[R2, T2])(implicit ec: ExecutionContext, ev: R <:< R2): Computation[R2, T2] = {
     Computation(future.flatMap {
-      case Left(x) => Future.successful(Left(x))
+      case Left(x)  => Future.successful(Left(x))
       case Right(x) => f(x).future
     })
   }
 
-  def processExceptions[R2](f: PartialFunction[Throwable, R2])
-                           (implicit ev1: R <:< R2,
-                            ec: ExecutionContext): Computation[R2, T] = {
+  def processExceptions[R2](f: PartialFunction[Throwable, R2])(implicit ev1: R <:< R2,
+                                                               ec: ExecutionContext): Computation[R2, T] = {
     val strategy = f.andThen(x => Left(x): Either[R2, T])
     val castedFuture: Future[Either[R2, T]] = future.map {
-      case Left(x) => Left(x)
+      case Left(x)  => Left(x)
       case Right(x) => Right(x)
     }
     Computation(castedFuture.recover(strategy))
@@ -80,16 +79,16 @@ final case class Computation[+R, +T](future: Future[Either[R, T]]) {
 
   def foreach[T2](f: T => T2)(implicit ec: ExecutionContext): Unit = future.foreach {
     case Right(x) => f(x)
-    case _ =>
+    case _        =>
   }
 
   def toFuture[R2](resultFormatter: T => R2)(implicit ec: ExecutionContext, ev: R <:< R2): Future[R2] = future.map {
-    case Left(x) => x
+    case Left(x)  => x
     case Right(x) => resultFormatter(x)
   }
 
   def toFuture[R2](implicit ec: ExecutionContext, ev1: R <:< R2, ev2: T <:< R2): Future[R2] = future.map {
-    case Left(x) => x
+    case Left(x)  => x
     case Right(x) => x
   }
 
@@ -104,6 +103,8 @@ object Computation {
   def fail(exception: Throwable): Computation[Nothing, Nothing] = Computation(Future.failed(exception))
 
   def fromFuture[T](input: Future[T])(implicit ec: ExecutionContext): Computation[Nothing, T] = Computation {
-    input.map { x => Right(x) }
+    input.map { x =>
+      Right(x)
+    }
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuicommon/utils/MapOps.scala b/src/main/scala/xyz/driver/pdsuicommon/utils/MapOps.scala
index 79f73a4..ac9a162 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/utils/MapOps.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/utils/MapOps.scala
@@ -3,9 +3,8 @@ package xyz.driver.pdsuicommon.utils
 final class MapOps[K, V](val self: Map[K, V]) extends AnyVal {
 
   def swap: Map[V, Set[K]] = {
-    self
-      .toList
-      .groupBy { case (_, v) => v }
+    self.toList
+      .groupBy { case (_, v)         => v }
       .mapValues(_.map { case (k, _) => k }.toSet)
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuicommon/utils/ServiceUtils.scala b/src/main/scala/xyz/driver/pdsuicommon/utils/ServiceUtils.scala
index 979c483..cf53e6b 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/utils/ServiceUtils.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/utils/ServiceUtils.scala
@@ -16,7 +16,7 @@ object ServiceUtils extends PhiLogging {
   def findEqFilter(filter: SearchFilterExpr, dimension: Dimension): Option[SearchFilterExpr] = {
     filter.find {
       case Atom.Binary(dimension, Eq, _) => true
-      case _ => false
+      case _                             => false
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/utils/Utils.scala b/src/main/scala/xyz/driver/pdsuicommon/utils/Utils.scala
index ad605e9..02c9e28 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/utils/Utils.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/utils/Utils.scala
@@ -15,7 +15,7 @@ object Utils {
       klass.getSimpleName
     } catch {
       case _: InternalError =>
-        val fullName = klass.getName.stripSuffix("$")
+        val fullName      = klass.getName.stripSuffix("$")
         val fullClassName = fullName.substring(fullName.lastIndexOf(".") + 1)
         fullClassName.substring(fullClassName.lastIndexOf("$") + 1)
     }
diff --git a/src/main/scala/xyz/driver/pdsuicommon/validation/Validators.scala b/src/main/scala/xyz/driver/pdsuicommon/validation/Validators.scala
index 5dd244e..fca726c 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/validation/Validators.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/validation/Validators.scala
@@ -22,9 +22,8 @@ object Validators extends PhiLogging {
     case x if x.nonEmpty => x
   }
 
-  def deserializableTo[Refined](field: String)
-                               (value: String)
-                               (implicit m: Manifest[Refined]): Either[ValidationError, Refined] = {
+  def deserializableTo[Refined](field: String)(value: String)(
+          implicit m: Manifest[Refined]): Either[ValidationError, Refined] = {
     try {
       Right(JsonSerializer.deserialize[Refined](value))
     } catch {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/Arm.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/Arm.scala
index 17a913d..70b84ff 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/Arm.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/Arm.scala
@@ -15,7 +15,6 @@ object Arm {
 
   implicit def toPhiString(x: Arm): PhiString = {
     import x._
-     phi"Arm(id=$id, name=${Unsafe(x.name)}, trialId=${Unsafe(x.trialId)})"
+    phi"Arm(id=$id, name=${Unsafe(x.name)}, trialId=${Unsafe(x.trialId)})"
   }
 }
-
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/DirectReport.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/DirectReport.scala
index c9d1d88..4f1f1b9 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/DirectReport.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/DirectReport.scala
@@ -16,11 +16,11 @@ object DirectReport {
   }
 
   object ReportType {
-    case object IHC extends ReportType
-    case object DNA extends ReportType
+    case object IHC   extends ReportType
+    case object DNA   extends ReportType
     case object CFDNA extends ReportType
 
-    val All = Set(IHC, DNA, CFDNA)
+    val All                                            = Set(IHC, DNA, CFDNA)
     implicit def toPhiString(x: ReportType): PhiString = Unsafe(Utils.getClassSimpleName(x.getClass))
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/Document.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/Document.scala
index 8c2616a..b10f67a 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/Document.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/Document.scala
@@ -14,7 +14,6 @@ import xyz.driver.pdsuicommon.validation.Validators.Validator
 import xyz.driver.pdsuidomain.entities.Document.Meta
 import xyz.driver.pdsuicommon.compat.Implicits._
 
-
 final case class ProviderType(id: LongId[ProviderType], name: String)
 
 object ProviderType {
@@ -36,6 +35,7 @@ object DocumentType {
 object Document {
 
   case class Meta(predicted: Option[Boolean], startPage: Double, endPage: Double) {
+
     /**
       * Return a regular meta: this meta is considered as not predicted
       */
@@ -51,9 +51,9 @@ object Document {
   class DocumentStatusDeserializer extends JsonDeserializer[Status] {
     def deserialize(parser: JsonParser, context: DeserializationContext): Status = {
       val value = parser.getValueAsString
-      Option(value).fold[Document.Status](Status.New /* Default document status */) { v =>
+      Option(value).fold[Document.Status](Status.New /* Default document status */ ) { v =>
         Status.All.find(_.toString.toUpperCase == v) match {
-          case None => throw new RuntimeJsonMappingException(s"$v is not valid Document.Status")
+          case None         => throw new RuntimeJsonMappingException(s"$v is not valid Document.Status")
           case Some(status) => status
         }
       }
@@ -72,14 +72,14 @@ object Document {
 
   }
   object Status {
-    case object New extends Status
+    case object New       extends Status
     case object Organized extends Status
     case object Extracted extends Status
-    case object Done extends Status
-    case object Flagged extends Status
-    case object Archived extends Status
+    case object Done      extends Status
+    case object Flagged   extends Status
+    case object Archived  extends Status
 
-    val All = Set[Status](New, Organized, Extracted, Done, Flagged, Archived)
+    val All         = Set[Status](New, Organized, Extracted, Done, Flagged, Archived)
     val AllPrevious = Set[Status](Organized, Extracted)
 
     implicit def toPhiString(x: Status): PhiString = Unsafe(Utils.getClassSimpleName(x.getClass))
@@ -101,15 +101,15 @@ object Document {
       startDate <- Validators.nonEmpty("startDate")(input.startDate)
 
       isOrderRight <- input.endDate match {
-        case Some(endDate) if startDate.isAfter(endDate) =>
-          Validators.fail("The start date should be less, than the end one")
+                       case Some(endDate) if startDate.isAfter(endDate) =>
+                         Validators.fail("The start date should be less, than the end one")
 
-        case _ => Validators.success(true)
-      }
+                       case _ => Validators.success(true)
+                     }
 
       areDatesInThePast <- {
-        val dates = List(input.startDate, input.endDate).flatten
-        val now = LocalDateTime.now()
+        val dates      = List(input.startDate, input.endDate).flatten
+        val now        = LocalDateTime.now()
         val hasInvalid = dates.exists(_.isAfter(now))
 
         if (hasInvalid) Validators.fail("Dates should be in the past")
@@ -129,7 +129,7 @@ case class Document(id: LongId[Document] = LongId(0L),
                     recordId: LongId[MedicalRecord],
                     physician: Option[String],
                     typeId: Option[LongId[DocumentType]], // not null
-                    providerName: Option[String],  // not null
+                    providerName: Option[String], // not null
                     providerTypeId: Option[LongId[ProviderType]], // not null
                     meta: Option[TextJson[Meta]], // not null
                     startDate: Option[LocalDateTime], // not null
@@ -139,8 +139,7 @@ case class Document(id: LongId[Document] = LongId(0L),
   import Document.Status._
 
   if (previousStatus.nonEmpty) {
-    assert(AllPrevious.contains(previousStatus.get),
-      s"Previous status has invalid value: ${previousStatus.get}")
+    assert(AllPrevious.contains(previousStatus.get), s"Previous status has invalid value: ${previousStatus.get}")
   }
 
   //  TODO: with the current business logic code this constraint sometimes harmful
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/Hypothesis.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/Hypothesis.scala
index eb2b95e..47b87ff 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/Hypothesis.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/Hypothesis.scala
@@ -3,10 +3,7 @@ package xyz.driver.pdsuidomain.entities
 import xyz.driver.pdsuicommon.domain.UuidId
 import xyz.driver.pdsuicommon.logging._
 
-final case class Hypothesis(id: UuidId[Hypothesis],
-                            name: String,
-                            treatmentType: String,
-                            description: String)
+final case class Hypothesis(id: UuidId[Hypothesis], name: String, treatmentType: String, description: String)
 
 object Hypothesis {
   implicit def toPhiString(x: Hypothesis): PhiString = {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/Intervention.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/Intervention.scala
index 6ff1a67..dc82050 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/Intervention.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/Intervention.scala
@@ -3,7 +3,6 @@ package xyz.driver.pdsuidomain.entities
 import xyz.driver.pdsuicommon.domain.{LongId, StringId}
 import xyz.driver.pdsuicommon.logging._
 
-
 final case class InterventionType(id: LongId[InterventionType], name: String)
 
 object InterventionType {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/Label.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/Label.scala
index 7f9c2aa..eea39de 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/Label.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/Label.scala
@@ -12,10 +12,7 @@ object Category {
   }
 }
 
-final case class Label(id: LongId[Label],
-                       categoryId: LongId[Category],
-                       name: String,
-                       description: String)
+final case class Label(id: LongId[Label], categoryId: LongId[Category], name: String, description: String)
 
 object Label {
   implicit def toPhiString(x: Label): PhiString = {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/MedicalRecord.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/MedicalRecord.scala
index 977f4cc..17de7de 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/MedicalRecord.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/MedicalRecord.scala
@@ -14,11 +14,12 @@ import xyz.driver.pdsuidomain.entities.MedicalRecord.Meta.{Duplicate, Reorder, R
 object MedicalRecord {
 
   @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
-  @JsonSubTypes(Array(
-    new Type(value = classOf[Duplicate], name = "duplicate"),
-    new Type(value = classOf[Reorder], name = "reorder"),
-    new Type(value = classOf[Rotation], name = "rotation")
-  ))
+  @JsonSubTypes(
+    Array(
+      new Type(value = classOf[Duplicate], name = "duplicate"),
+      new Type(value = classOf[Reorder], name = "reorder"),
+      new Type(value = classOf[Rotation], name = "rotation")
+    ))
   trait Meta {
     @JsonProperty("type") def metaType: String
     def predicted: Option[Boolean]
@@ -35,9 +36,9 @@ object MedicalRecord {
                          startPage: Double,
                          endPage: Double,
                          startOriginalPage: Double,
-                         endOriginalPage: Option[Double]
-                        ) extends Meta {
-      override val metaType = "duplicate"
+                         endOriginalPage: Option[Double])
+        extends Meta {
+      override val metaType             = "duplicate"
       override def confirmed: Duplicate = copy(predicted = predicted.map(_ => false))
     }
 
@@ -49,11 +50,8 @@ object MedicalRecord {
       }
     }
 
-
-    case class Reorder(predicted: Option[Boolean],
-                       items: Seq[Int]
-                      ) extends Meta {
-      override val metaType = "reorder"
+    case class Reorder(predicted: Option[Boolean], items: Seq[Int]) extends Meta {
+      override val metaType           = "reorder"
       override def confirmed: Reorder = copy(predicted = predicted.map(_ => false))
     }
 
@@ -64,11 +62,8 @@ object MedicalRecord {
       }
     }
 
-
-    case class Rotation(predicted: Option[Boolean],
-                        items: Map[String, Int]
-                       ) extends Meta {
-      override val metaType = "rotation"
+    case class Rotation(predicted: Option[Boolean], items: Map[String, Int]) extends Meta {
+      override val metaType            = "rotation"
       override def confirmed: Rotation = copy(predicted = predicted.map(_ => false))
     }
 
@@ -79,11 +74,10 @@ object MedicalRecord {
       }
     }
 
-
     implicit def toPhiString(input: Meta): PhiString = input match {
       case x: Duplicate => Duplicate.toPhiString(x)
-      case x: Reorder => Reorder.toPhiString(x)
-      case x: Rotation => Rotation.toPhiString(x)
+      case x: Reorder   => Reorder.toPhiString(x)
+      case x: Rotation  => Rotation.toPhiString(x)
     }
 
   }
@@ -98,20 +92,30 @@ object MedicalRecord {
 
   }
   object Status {
-    case object Unprocessed extends Status
-    case object PreCleaning extends Status
-    case object New extends Status
-    case object Cleaned extends Status
-    case object PreOrganized extends Status
+    case object Unprocessed   extends Status
+    case object PreCleaning   extends Status
+    case object New           extends Status
+    case object Cleaned       extends Status
+    case object PreOrganized  extends Status
     case object PreOrganizing extends Status
-    case object Reviewed extends Status
-    case object Organized extends Status
-    case object Done extends Status
-    case object Flagged extends Status
-    case object Archived extends Status
+    case object Reviewed      extends Status
+    case object Organized     extends Status
+    case object Done          extends Status
+    case object Flagged       extends Status
+    case object Archived      extends Status
 
     val All = Set[Status](
-      Unprocessed, PreCleaning, New, Cleaned, PreOrganized, PreOrganizing, Reviewed, Organized, Done, Flagged, Archived
+      Unprocessed,
+      PreCleaning,
+      New,
+      Cleaned,
+      PreOrganized,
+      PreOrganizing,
+      Reviewed,
+      Organized,
+      Done,
+      Flagged,
+      Archived
     )
 
     val AllPrevious = Set[Status](New, Cleaned, Reviewed, Organized)
@@ -123,6 +127,7 @@ object MedicalRecord {
 
   object PdfSource {
     case object Empty extends PdfSource
+
     /** @param createResource Constructor of the resource which is represents the file */
     case class Channel(createResource: () => ReadableByteChannel) extends PdfSource
   }
@@ -152,8 +157,7 @@ case class MedicalRecord(id: LongId[MedicalRecord],
   import MedicalRecord.Status._
 
   if (previousStatus.nonEmpty) {
-    assert(AllPrevious.contains(previousStatus.get),
-      s"Previous status has invalid value: ${previousStatus.get}")
+    assert(AllPrevious.contains(previousStatus.get), s"Previous status has invalid value: ${previousStatus.get}")
   }
 
   //  TODO: with the current business logic code this constraint sometimes harmful
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/Patient.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/Patient.scala
index 7767db0..bc80ce3 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/Patient.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/Patient.scala
@@ -17,19 +17,27 @@ object Patient {
   }
 
   object Status {
-    case object New extends Status
+    case object New      extends Status
     case object Verified extends Status
     case object Reviewed extends Status
-    case object Curated extends Status
-    case object Flagged extends Status
-    case object Done extends Status
+    case object Curated  extends Status
+    case object Flagged  extends Status
+    case object Done     extends Status
 
     val AllPrevious = Set[Status](
-      New, Verified, Reviewed, Curated
+      New,
+      Verified,
+      Reviewed,
+      Curated
     )
 
     val All = Set[Status](
-      New, Verified, Reviewed, Curated, Flagged, Done
+      New,
+      Verified,
+      Reviewed,
+      Curated,
+      Flagged,
+      Done
     )
 
     implicit def toPhiString(x: Status): PhiString = Unsafe(Utils.getClassSimpleName(x.getClass))
@@ -57,7 +65,6 @@ case class Patient(id: UuidId[Patient],
   import Patient.Status._
 
   if (previousStatus.nonEmpty) {
-    assert(AllPrevious.contains(previousStatus.get),
-      s"Previous status has invalid value: ${previousStatus.get}")
+    assert(AllPrevious.contains(previousStatus.get), s"Previous status has invalid value: ${previousStatus.get}")
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientEligibleTrial.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientEligibleTrial.scala
index 8d5af0d..5df5253 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientEligibleTrial.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientEligibleTrial.scala
@@ -18,17 +18,17 @@ object PatientCriterion {
   /**
     * @see https://driverinc.atlassian.net/wiki/display/MTCH/EV+Business+Process
     */
-  def getEligibilityStatus(criterionValue: Option[Boolean],
-                           primaryValue: Option[FuzzyValue]): Option[FuzzyValue] = {
+  def getEligibilityStatus(criterionValue: Option[Boolean], primaryValue: Option[FuzzyValue]): Option[FuzzyValue] = {
     primaryValue match {
-      case None => None
-      case Some(FuzzyValue.Maybe) => Some(FuzzyValue.Maybe)
+      case None                              => None
+      case Some(FuzzyValue.Maybe)            => Some(FuzzyValue.Maybe)
       case Some(_) if criterionValue.isEmpty => Some(FuzzyValue.Maybe)
-      case Some(status) => Some(FuzzyValue.fromBoolean(
-        FuzzyValue.fromBoolean(criterionValue.getOrElse(
-          throw new IllegalArgumentException("Criterion should not be empty"))
-        ) == status
-      ))
+      case Some(status) =>
+        Some(
+          FuzzyValue.fromBoolean(
+            FuzzyValue.fromBoolean(
+              criterionValue.getOrElse(throw new IllegalArgumentException("Criterion should not be empty"))) == status
+          ))
     }
   }
 
@@ -93,15 +93,18 @@ object PatientTrialArmGroup {
       // Eligible, if for all (verified for EV) label-criteria eligibilityStatus=NULL or YES and at least one has status=YES
       // If method executes from PatientService (when EV submit patient) need to check value PatientCriterion.isVerified
       val verifiedList = criterionList.filter { case (isVerifiedOpt, _) => isVerifiedOpt.isEmpty || isVerifiedOpt.get }
-      verifiedList.forall { case (_, eligibilityStatus) =>
-        eligibilityStatus.isEmpty || eligibilityStatus.contains(FuzzyValue.Yes)
+      verifiedList.forall {
+        case (_, eligibilityStatus) =>
+          eligibilityStatus.isEmpty || eligibilityStatus.contains(FuzzyValue.Yes)
       } && verifiedList.exists { case (_, eligibilityStatus) => eligibilityStatus.contains(FuzzyValue.Yes) }
     }
 
-    if (criterionList.exists { case (isVerified, eligibilityStatus) =>
-      eligibilityStatus.contains(FuzzyValue.No) && (isVerified.isEmpty || isVerified.get)
-    }) { Some(FuzzyValue.No)
-    } else if (criterionList.forall { case (_, eligibilityStatus) => eligibilityStatus.isEmpty }) {
+    if (criterionList.exists {
+          case (isVerified, eligibilityStatus) =>
+            eligibilityStatus.contains(FuzzyValue.No) && (isVerified.isEmpty || isVerified.get)
+        }) { Some(FuzzyValue.No) } else if (criterionList.forall {
+                                              case (_, eligibilityStatus) => eligibilityStatus.isEmpty
+                                            }) {
       None
     } else if (isEligible) {
       Some(FuzzyValue.Yes)
@@ -114,9 +117,9 @@ object PatientTrialArmGroup {
     * @see https://driverinc.atlassian.net/wiki/display/DMPD/EV+Business+Process
     */
   def getEligibilityStatusForRc(criterionList: TraversableOnce[PatientCriterion]): Option[FuzzyValue] = {
-    def isEligible: Boolean = criterionList.forall(_.verifiedEligibilityStatus.contains(FuzzyValue.Yes))
+    def isEligible: Boolean   = criterionList.forall(_.verifiedEligibilityStatus.contains(FuzzyValue.Yes))
     def isIneligible: Boolean = criterionList.exists(_.verifiedEligibilityStatus.contains(FuzzyValue.No))
-    def isUnknown: Boolean = criterionList.forall(_.verifiedEligibilityStatus.isEmpty)
+    def isUnknown: Boolean    = criterionList.forall(_.verifiedEligibilityStatus.isEmpty)
 
     if (isEligible) Some(FuzzyValue.Yes)
     else if (isIneligible) Some(FuzzyValue.No)
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/Trial.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/Trial.scala
index 2477c22..f5ab3cb 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/Trial.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/Trial.scala
@@ -8,7 +8,6 @@ import xyz.driver.pdsuicommon.logging._
 import xyz.driver.pdsuicommon.utils.Utils
 import xyz.driver.pdsuidomain.entities.Trial.{Condition, Status}
 
-
 final case class StudyDesign(id: LongId[StudyDesign], name: String)
 
 object StudyDesign {
@@ -21,23 +20,31 @@ object StudyDesign {
 object Trial {
 
   sealed trait Status {
-    def oneOf(xs: Status*): Boolean = xs.contains(this)
+    def oneOf(xs: Status*): Boolean     = xs.contains(this)
     def oneOf(xs: Set[Status]): Boolean = xs.contains(this)
   }
 
   object Status {
-    case object New extends Status
-    case object ReviewSummary extends Status
-    case object Summarized extends Status
-    case object PendingUpdate extends Status
-    case object Update extends Status
+    case object New            extends Status
+    case object ReviewSummary  extends Status
+    case object Summarized     extends Status
+    case object PendingUpdate  extends Status
+    case object Update         extends Status
     case object ReviewCriteria extends Status
-    case object Done extends Status
-    case object Flagged extends Status
-    case object Archived extends Status
+    case object Done           extends Status
+    case object Flagged        extends Status
+    case object Archived       extends Status
 
     val All = Set[Status](
-      New, ReviewSummary, Summarized, PendingUpdate, Update, ReviewCriteria, Done, Flagged, Archived
+      New,
+      ReviewSummary,
+      Summarized,
+      PendingUpdate,
+      Update,
+      ReviewCriteria,
+      Done,
+      Flagged,
+      Archived
     )
 
     val AllPrevious = Set[Status](New, ReviewSummary, Summarized, ReviewCriteria)
@@ -60,8 +67,8 @@ object Trial {
 
   object Condition {
 
-    case object Breast extends Condition
-    case object Lung extends Condition
+    case object Breast   extends Condition
+    case object Lung     extends Condition
     case object Prostate extends Condition
 
     val All = Set(Breast, Lung, Prostate)
@@ -96,7 +103,6 @@ final case class Trial(id: StringId[Trial],
   import Trial.Status._
 
   if (previousStatus.nonEmpty) {
-    assert(AllPrevious.contains(previousStatus.get),
-      s"Previous status has invalid value: ${previousStatus.get}")
+    assert(AllPrevious.contains(previousStatus.get), s"Previous status has invalid value: ${previousStatus.get}")
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientLabel.scala
index 7d5de79..3b7a6ad 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientLabel.scala
@@ -4,9 +4,7 @@ import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuicommon.logging._
 import xyz.driver.pdsuidomain.entities.{Label, RawPatientLabel}
 
-case class ExportPatientLabel(id: LongId[Label],
-                              name: String,
-                              evidences: List[ExportPatientLabelEvidence])
+case class ExportPatientLabel(id: LongId[Label], name: String, evidences: List[ExportPatientLabelEvidence])
 
 object ExportPatientLabel extends PhiLogging {
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientWithLabels.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientWithLabels.scala
index 418f20b..718255b 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientWithLabels.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientWithLabels.scala
@@ -15,8 +15,7 @@ object ExportPatientWithLabels {
     phi"ExportPatientWithLabels(patientId=$patientId, version=${Unsafe(labelVersion)}, labels=$labels)"
   }
 
-  def fromRaw(patientId: UuidId[Patient],
-              rawPatientRefs: List[RawPatientLabel]) = ExportPatientWithLabels(
+  def fromRaw(patientId: UuidId[Patient], rawPatientRefs: List[RawPatientLabel]) = ExportPatientWithLabels(
     patientId = patientId,
     labelVersion = 1L, // TODO It is needed to replace this mock label version.
     labels = rawPatientRefs
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/export/trial/ExportTrialWithLabels.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/export/trial/ExportTrialWithLabels.scala
index 251f6fb..2580e54 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/export/trial/ExportTrialWithLabels.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/export/trial/ExportTrialWithLabels.scala
@@ -36,16 +36,21 @@ object ExportTrialWithLabels {
       condition = trial.condition,
       lastReviewed = trial.lastReviewed,
       labelVersion = 1, // TODO It is needed to replace this mock label version.
-      arms = rawData.groupBy(_.armId).map { case (armId, rawTrials) =>
-        ExportTrialArm(armId, rawTrials.head.armName)
-      }(breakOut),
-      criteria = rawData.groupBy { x =>
-        (x.criterionId, x.labelId)
-      }.map {
-        case (_, rawTrialLabels) =>
-          val armIds = rawTrialLabels.map(_.criterionArmId).toSet
-          ExportTrialLabelCriterion.fromRaw(rawTrialLabels.head, armIds)
-      }(breakOut)
+      arms = rawData
+        .groupBy(_.armId)
+        .map {
+          case (armId, rawTrials) =>
+            ExportTrialArm(armId, rawTrials.head.armName)
+        }(breakOut),
+      criteria = rawData
+        .groupBy { x =>
+          (x.criterionId, x.labelId)
+        }
+        .map {
+          case (_, rawTrialLabels) =>
+            val armIds = rawTrialLabels.map(_.criterionArmId).toSet
+            ExportTrialLabelCriterion.fromRaw(rawTrialLabels.head, armIds)
+        }(breakOut)
     )
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/CategoryService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/CategoryService.scala
index 31ccff7..a735ade 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/CategoryService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/CategoryService.scala
@@ -13,8 +13,7 @@ object CategoryService {
   object GetListReply {
     case class EntityList(xs: Seq[CategoryWithLabels], totalFound: Int) extends GetListReply
 
-    case object AuthorizationError
-      extends GetListReply with DomainError.AuthorizationError {
+    case object AuthorizationError extends GetListReply with DomainError.AuthorizationError {
       def userMessage: String = "Access denied"
     }
   }
@@ -24,5 +23,6 @@ trait CategoryService extends PhiLogging {
 
   import CategoryService._
 
-  def getAll(sorting: Option[Sorting] = None)(implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
+  def getAll(sorting: Option[Sorting] = None)(
+          implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/ExportService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/ExportService.scala
index eaffb2a..5be037c 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/ExportService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/ExportService.scala
@@ -29,7 +29,7 @@ object ExportService {
   sealed trait GetTrialListReply
   object GetTrialListReply {
     case class EntityList(xs: Seq[ExportTrial], totalFound: Int, lastUpdate: Option[LocalDateTime])
-      extends GetTrialListReply
+        extends GetTrialListReply
   }
 
   sealed trait GetTrialReply
@@ -48,13 +48,12 @@ trait ExportService extends PhiLogging {
 
   import ExportService._
 
-  def getPatient(id: UuidId[Patient])
-                (implicit requestContext: AnonymousRequestContext): Future[GetPatientReply]
+  def getPatient(id: UuidId[Patient])(implicit requestContext: AnonymousRequestContext): Future[GetPatientReply]
 
-  def getTrialList(filter: SearchFilterExpr = SearchFilterExpr.Empty)
-                  (implicit requestContext: AnonymousRequestContext): Future[GetTrialListReply]
+  def getTrialList(filter: SearchFilterExpr = SearchFilterExpr.Empty)(
+          implicit requestContext: AnonymousRequestContext): Future[GetTrialListReply]
 
-  def getTrial(trialId: StringId[Trial], condition: String)
-              (implicit requestContext: AnonymousRequestContext): Future[GetTrialReply]
+  def getTrial(trialId: StringId[Trial], condition: String)(
+          implicit requestContext: AnonymousRequestContext): Future[GetTrialReply]
 
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/LabelService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/LabelService.scala
index 25291f1..0677584 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/LabelService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/LabelService.scala
@@ -14,8 +14,7 @@ object LabelService {
   object GetListReply {
     case class EntityList(xs: Seq[Label], totalFound: Int) extends GetListReply
 
-    case object AuthorizationError
-      extends GetListReply with DomainError.AuthorizationError {
+    case object AuthorizationError extends GetListReply with DomainError.AuthorizationError {
       def userMessage: String = "Access denied"
     }
   }
@@ -24,6 +23,6 @@ object LabelService {
 trait LabelService extends PhiLogging {
   import LabelService._
 
-  def getAll(sorting: Option[Sorting] = None)
-            (implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
+  def getAll(sorting: Option[Sorting] = None)(
+          implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/MessageService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/MessageService.scala
index 56140ce..8ce06f2 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/MessageService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/MessageService.scala
@@ -24,45 +24,37 @@ object MessageService {
   sealed trait CreateReply
   object CreateReply {
     type Error = CreateReply with DomainError
-    case class Created(x: Message)
-      extends CreateReply
+    case class Created(x: Message) extends CreateReply
     case object AuthorizationError
-      extends CreateReply with DomainError.AuthorizationError with DefaultAccessDeniedError
-    case class CommonError(userMessage: String)
-      extends CreateReply with DomainError
+        extends CreateReply with DomainError.AuthorizationError with DefaultAccessDeniedError
+    case class CommonError(userMessage: String) extends CreateReply with DomainError
   }
 
   sealed trait GetByIdReply
   object GetByIdReply {
     type Error = GetByIdReply with DomainError
-    case class Entity(x: Message)
-      extends GetByIdReply
-    case object NotFoundError
-      extends GetByIdReply with DomainError.NotFoundError with DefaultNotFoundError
-    case class CommonError(userMessage: String)
-      extends GetByIdReply with DomainError
+    case class Entity(x: Message)               extends GetByIdReply
+    case object NotFoundError                   extends GetByIdReply with DomainError.NotFoundError with DefaultNotFoundError
+    case class CommonError(userMessage: String) extends GetByIdReply with DomainError
     case object AuthorizationError
-      extends GetByIdReply with DomainError.AuthorizationError with DefaultAccessDeniedError
+        extends GetByIdReply with DomainError.AuthorizationError with DefaultAccessDeniedError
   }
 
   sealed trait GetListReply
   object GetListReply {
     type Error = GetListReply with DomainError
-    case class EntityList(xs: Seq[Message], totalFound: Int, lastUpdate: Option[LocalDateTime])
-      extends GetListReply
+    case class EntityList(xs: Seq[Message], totalFound: Int, lastUpdate: Option[LocalDateTime]) extends GetListReply
     case object AuthorizationError
-      extends GetListReply with DomainError.AuthorizationError with DefaultAccessDeniedError
+        extends GetListReply with DomainError.AuthorizationError with DefaultAccessDeniedError
   }
 
   sealed trait UpdateReply
   object UpdateReply {
     type Error = UpdateReply with DomainError
-    case class Updated(updated: Message)
-      extends UpdateReply
+    case class Updated(updated: Message) extends UpdateReply
     case object AuthorizationError
-      extends UpdateReply with DomainError.AuthorizationError with DefaultAccessDeniedError
-    case class CommonError(userMessage: String)
-      extends UpdateReply with DomainError
+        extends UpdateReply with DomainError.AuthorizationError with DefaultAccessDeniedError
+    case class CommonError(userMessage: String) extends UpdateReply with DomainError
   }
 
   sealed trait DeleteReply
@@ -70,11 +62,9 @@ object MessageService {
     type Error = DeleteReply with DomainError
     case object Deleted extends DeleteReply
     case object AuthorizationError
-      extends DeleteReply with DomainError.AuthorizationError with DefaultAccessDeniedError
-    case object NotFoundError
-      extends DeleteReply with DomainError.NotFoundError with DefaultNotFoundError
-    case class CommonError(userMessage: String)
-      extends DeleteReply with DomainError
+        extends DeleteReply with DomainError.AuthorizationError with DefaultAccessDeniedError
+    case object NotFoundError                   extends DeleteReply with DomainError.NotFoundError with DefaultNotFoundError
+    case class CommonError(userMessage: String) extends DeleteReply with DomainError
   }
 
 }
@@ -89,12 +79,11 @@ trait MessageService extends PhiLogging {
 
   def getAll(filter: SearchFilterExpr = SearchFilterExpr.Empty,
              sorting: Option[Sorting] = None,
-             pagination: Option[Pagination] = None)
-            (implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
+             pagination: Option[Pagination] = None)(
+          implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
 
-  def update(origMessage: Message, draftMessage: Message)
-            (implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply]
+  def update(origMessage: Message, draftMessage: Message)(
+          implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply]
 
-  def delete(messageId: LongId[Message])
-            (implicit requestContext: AuthenticatedRequestContext): Future[DeleteReply]
+  def delete(messageId: LongId[Message])(implicit requestContext: AuthenticatedRequestContext): Future[DeleteReply]
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/UserService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/UserService.scala
index 350720e..79e9835 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/UserService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/UserService.scala
@@ -26,8 +26,7 @@ object UserService {
   object ActivateExecutorReply {
     type Error = ActivateExecutorReply with DomainError
     case class Entity(x: User) extends ActivateExecutorReply
-    case object NotFoundError
-      extends ActivateExecutorReply with DomainError.NotFoundError {
+    case object NotFoundError extends ActivateExecutorReply with DomainError.NotFoundError {
       val userMessage = "Info about you is not found on the server"
     }
   }
@@ -37,18 +36,15 @@ object UserService {
     type Error = GetByIdReply with DomainError
     case class Entity(x: User) extends GetByIdReply
     case object AuthorizationError
-      extends GetByIdReply with DomainError.AuthorizationError with DefaultAccessDeniedError
-    case object NotFoundError
-      extends GetByIdReply with DomainError.NotFoundError with DefaultNotFoundError
-    case class CommonError(userMessage: String)
-      extends GetByIdReply with DomainError
+        extends GetByIdReply with DomainError.AuthorizationError with DefaultAccessDeniedError
+    case object NotFoundError                   extends GetByIdReply with DomainError.NotFoundError with DefaultNotFoundError
+    case class CommonError(userMessage: String) extends GetByIdReply with DomainError
   }
 
   sealed trait GetByEmailReply
   object GetByEmailReply {
     case class Entity(x: User) extends GetByEmailReply
-    case object NotFoundError
-      extends GetByEmailReply with DefaultNotFoundError with DomainError.NotFoundError {
+    case object NotFoundError extends GetByEmailReply with DefaultNotFoundError with DomainError.NotFoundError {
       override def userMessage: String = "Incorrect email. Try again."
     }
   }
@@ -57,30 +53,25 @@ object UserService {
   object GetByCredentialsReply {
     case class Entity(x: User) extends GetByCredentialsReply
     case object AuthenticationError
-      extends GetByCredentialsReply with DefaultCredentialsError with DomainError.AuthenticationError
-    case object NotFoundError
-      extends GetByCredentialsReply with DomainError.NotFoundError with DefaultNotFoundError
+        extends GetByCredentialsReply with DefaultCredentialsError with DomainError.AuthenticationError
+    case object NotFoundError extends GetByCredentialsReply with DomainError.NotFoundError with DefaultNotFoundError
   }
 
   sealed trait GetListReply
   object GetListReply {
     case class EntityList(xs: Seq[User], totalFound: Int) extends GetListReply
-    case object AuthorizationError
-      extends GetListReply with DomainError.AuthorizationError with DefaultNotFoundError
+    case object AuthorizationError                        extends GetListReply with DomainError.AuthorizationError with DefaultNotFoundError
   }
 
   sealed trait CreateReply
   object CreateReply {
     type Error = CreateReply with DomainError
-    case class Created(x: User) extends CreateReply
-    case object AuthorizationError
-      extends CreateReply with DefaultNotFoundError with DomainError.AuthorizationError
-    case class UserAlreadyExistsError(email: Email)
-      extends CreateReply with DomainError {
+    case class Created(x: User)    extends CreateReply
+    case object AuthorizationError extends CreateReply with DefaultNotFoundError with DomainError.AuthorizationError
+    case class UserAlreadyExistsError(email: Email) extends CreateReply with DomainError {
       val userMessage = s"The user with this email already exists."
     }
-    case class CommonError(userMessage: String)
-      extends CreateReply with DomainError
+    case class CommonError(userMessage: String) extends CreateReply with DomainError
   }
 
   sealed trait UpdateReply
@@ -88,9 +79,8 @@ object UserService {
     type Error = UpdateReply with DomainError
     case class Updated(updated: User) extends UpdateReply
     case object AuthorizationError
-      extends UpdateReply with DefaultAccessDeniedError with DomainError.AuthorizationError
-    case class CommonError(userMessage: String)
-      extends UpdateReply with DomainError
+        extends UpdateReply with DefaultAccessDeniedError with DomainError.AuthorizationError
+    case class CommonError(userMessage: String) extends UpdateReply with DomainError
   }
 
   sealed trait DeleteReply
@@ -98,15 +88,12 @@ object UserService {
     type Error = DeleteReply with DomainError
     case object Deleted extends DeleteReply
     case class AuthorizationError(user: User)
-      extends DeleteReply with DefaultAccessDeniedError with DomainError.AuthorizationError
-    case object AssignedToRecordAndDocumentError
-      extends DeleteReply with DomainError {
+        extends DeleteReply with DefaultAccessDeniedError with DomainError.AuthorizationError
+    case object AssignedToRecordAndDocumentError extends DeleteReply with DomainError {
       val userMessage = "User is can not be deleted because he has record and document in work"
     }
-    case object NotFoundError
-      extends DeleteReply with DefaultNotFoundError with DomainError.NotFoundError
-    case class CommonError(userMessage: String)
-      extends DeleteReply with DomainError
+    case object NotFoundError                   extends DeleteReply with DefaultNotFoundError with DomainError.NotFoundError
+    case class CommonError(userMessage: String) extends DeleteReply with DomainError
   }
 
 }
@@ -118,26 +105,25 @@ trait UserService extends PhiLogging {
   /**
     * Utility method for getting request executor.
     */
-  def activateExecutor(executorId: LongId[User])
-                      (implicit requestContext: AnonymousRequestContext): Future[ActivateExecutorReply]
+  def activateExecutor(executorId: LongId[User])(
+          implicit requestContext: AnonymousRequestContext): Future[ActivateExecutorReply]
 
   def getById(userId: LongId[User])(implicit requestContext: AuthenticatedRequestContext): Future[GetByIdReply]
 
-  def getByEmail(email: Email)
-                (implicit requestContext: AnonymousRequestContext): Future[GetByEmailReply]
+  def getByEmail(email: Email)(implicit requestContext: AnonymousRequestContext): Future[GetByEmailReply]
 
-  def getByCredentials(email: Email, password: String)
-                      (implicit requestContext: AnonymousRequestContext): Future[GetByCredentialsReply]
+  def getByCredentials(email: Email, password: String)(
+          implicit requestContext: AnonymousRequestContext): Future[GetByCredentialsReply]
 
   def getAll(filter: SearchFilterExpr = SearchFilterExpr.Empty,
              sorting: Option[Sorting] = None,
-             pagination: Option[Pagination] = None)
-            (implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
+             pagination: Option[Pagination] = None)(
+          implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
 
   def create(draftUser: User)(implicit requestContext: AuthenticatedRequestContext): Future[CreateReply]
 
-  def update(origUser: User, draftUser: User)
-            (implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply]
+  def update(origUser: User, draftUser: User)(
+          implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply]
 
   def delete(userId: LongId[User])(implicit requestContext: AuthenticatedRequestContext): Future[DeleteReply]
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/storage/MedicalRecordDocumentStorage.scala b/src/main/scala/xyz/driver/pdsuidomain/storage/MedicalRecordDocumentStorage.scala
index d50be2c..192512f 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/storage/MedicalRecordDocumentStorage.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/storage/MedicalRecordDocumentStorage.scala
@@ -9,8 +9,7 @@ import scala.concurrent.{ExecutionContext, Future, blocking}
 object MedicalRecordDocumentStorage extends StrictLogging {
   private val storage = StorageOptions.getDefaultInstance.getService
 
-  def fetchPdf(bucket: String, path: String)
-              (implicit ec: ExecutionContext): Future[PdfSource] = {
+  def fetchPdf(bucket: String, path: String)(implicit ec: ExecutionContext): Future[PdfSource] = {
     logger.trace(s"fetchPdf(bucket=$bucket, path=$path)")
     Future {
       blocking {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/storage/RequestStorage.scala b/src/main/scala/xyz/driver/pdsuidomain/storage/RequestStorage.scala
index d9651ca..9e3ad67 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/storage/RequestStorage.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/storage/RequestStorage.scala
@@ -7,7 +7,7 @@ import xyz.driver.pdsuidomain.entities.{Arm, Patient}
 import scala.collection.concurrent.TrieMap
 
 object RequestStorage {
-  type Key = (UuidId[Patient], String)
+  type Key   = (UuidId[Patient], String)
   type Value = Set[LongId[Arm]]
 }
 
@@ -16,9 +16,7 @@ class RequestStorage extends PhiLogging {
 
   private val storage = new TrieMap[Key, Value]()
 
-  def put(patientId: UuidId[Patient],
-          disease: String,
-          ineligibleArms: Set[LongId[Arm]]): Unit = {
+  def put(patientId: UuidId[Patient], disease: String, ineligibleArms: Set[LongId[Arm]]): Unit = {
     logger.debug(phi"put($patientId, ${Unsafe(disease)}, $ineligibleArms")
     val key = (patientId, disease.toLowerCase)
     get(patientId, disease.toLowerCase) match {
@@ -37,9 +35,7 @@ class RequestStorage extends PhiLogging {
     storage.get(key)
   }
 
-  def contains(patientId: UuidId[Patient],
-               disease: String,
-               value: Set[LongId[Arm]]): Boolean = {
+  def contains(patientId: UuidId[Patient], disease: String, value: Set[LongId[Arm]]): Boolean = {
     logger.debug(phi"contains(key=($patientId,${Unsafe(disease)}),value=$value")
     get(patientId, disease.toLowerCase).contains(value)
   }
diff --git a/src/test/scala/xyz/driver/pdsuicommon/BaseSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/BaseSuite.scala
index 78a9168..656ee24 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/BaseSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/BaseSuite.scala
@@ -16,11 +16,9 @@ import scala.concurrent.Future
 trait BaseSuite extends FreeSpecLike with DiffUtils with ScalaFutures {
 
   implicit val defaultPatience = PatienceConfig(timeout = Span(1000, Millis), interval = Span(20, Millis))
-  implicit val sqlContext = new MockSqlContext(global)
+  implicit val sqlContext      = new MockSqlContext(global)
 
-  def sampleUser(role: User.Role,
-                 email: String = "test@example.com",
-                 password: String = "123") = User(
+  def sampleUser(role: User.Role, email: String = "test@example.com", password: String = "123") = User(
     id = LongId(2001),
     email = Email(email),
     name = "Test",
diff --git a/src/test/scala/xyz/driver/pdsuicommon/Mocks.scala b/src/test/scala/xyz/driver/pdsuicommon/Mocks.scala
index 2154e3d..d4b4d3c 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/Mocks.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/Mocks.scala
@@ -17,13 +17,13 @@ class MockDataSource extends DataSource with Closeable {
   override def getConnection(username: String, password: String): Connection = {
     throw new NotImplementedError(s"MockDataSource.getConnection($username, $password)")
   }
-  override def close(): Unit = throw new NotImplementedError("MockDataSource.close")
-  override def setLogWriter(out: PrintWriter): Unit = throw new NotImplementedError("MockDataSource.setLogWriter")
-  override def getLoginTimeout: Int = throw new NotImplementedError("MockDataSource.getLoginTimeout")
-  override def setLoginTimeout(seconds: Int): Unit = throw new NotImplementedError("MockDataSource.setLoginTimeout")
-  override def getParentLogger: Logger = throw new NotImplementedError("MockDataSource.getParentLogger")
-  override def getLogWriter: PrintWriter = throw new NotImplementedError("MockDataSource.getLogWriter")
-  override def unwrap[T](iface: Class[T]): T = throw new NotImplementedError("MockDataSource.unwrap")
+  override def close(): Unit                          = throw new NotImplementedError("MockDataSource.close")
+  override def setLogWriter(out: PrintWriter): Unit   = throw new NotImplementedError("MockDataSource.setLogWriter")
+  override def getLoginTimeout: Int                   = throw new NotImplementedError("MockDataSource.getLoginTimeout")
+  override def setLoginTimeout(seconds: Int): Unit    = throw new NotImplementedError("MockDataSource.setLoginTimeout")
+  override def getParentLogger: Logger                = throw new NotImplementedError("MockDataSource.getParentLogger")
+  override def getLogWriter: PrintWriter              = throw new NotImplementedError("MockDataSource.getLogWriter")
+  override def unwrap[T](iface: Class[T]): T          = throw new NotImplementedError("MockDataSource.unwrap")
   override def isWrapperFor(iface: Class[_]): Boolean = throw new NotImplementedError("MockDataSource.isWrapperFor")
 }
 
@@ -63,13 +63,13 @@ class MockFactory()(implicit val sqlContext: SqlContext) {
 
 object MockQueryBuilder {
 
-  type MockRunnerIn = (SearchFilterExpr, Sorting, Option[Pagination])
-  type MockRunnerOut[T] = Future[Seq[T]]
+  type MockRunnerIn       = (SearchFilterExpr, Sorting, Option[Pagination])
+  type MockRunnerOut[T]   = Future[Seq[T]]
   type MockCountRunnerOut = Future[QueryBuilder.CountResult]
 
-  def apply[T](matcher: PartialFunction[MockRunnerIn, MockRunnerOut[T]])
-              (countMatcher: PartialFunction[MockRunnerIn, MockCountRunnerOut])
-              (implicit context: SqlContext): MysqlQueryBuilder[T] = {
+  def apply[T](matcher: PartialFunction[MockRunnerIn, MockRunnerOut[T]])(
+          countMatcher: PartialFunction[MockRunnerIn, MockCountRunnerOut])(
+          implicit context: SqlContext): MysqlQueryBuilder[T] = {
     def runner(parameters: QueryBuilderParameters): MockRunnerOut[T] = {
       matcher((parameters.filter, parameters.sorting, parameters.pagination))
     }
@@ -86,4 +86,3 @@ object MockQueryBuilder {
     )(context.executionContext)
   }
 }
-
diff --git a/src/test/scala/xyz/driver/pdsuicommon/concurrent/BridgeUploadQueueRepositoryAdapterSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/concurrent/BridgeUploadQueueRepositoryAdapterSuite.scala
index c0bb1a2..48a4eaf 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/concurrent/BridgeUploadQueueRepositoryAdapterSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/concurrent/BridgeUploadQueueRepositoryAdapterSuite.scala
@@ -29,11 +29,11 @@ class BridgeUploadQueueRepositoryAdapterSuite extends BaseSuite {
 
         "a new interval should be greater than the previous one if the limit not reached" in {
           val previous = strategy.on(1)
-          val current = strategy.on(2)
+          val current  = strategy.on(2)
 
           (previous, current) match {
             case (OnAttempt.Continue(a), OnAttempt.Continue(b)) => assert(a < b)
-            case x => fail(s"Unexpected result: $x")
+            case x                                              => fail(s"Unexpected result: $x")
           }
         }
 
@@ -52,11 +52,12 @@ class BridgeUploadQueueRepositoryAdapterSuite extends BaseSuite {
 
       "should return an updated item" in {
         val repository = new BridgeUploadQueueRepository {
-          override def update(draft: EntityT): EntityT = draft
-          override def delete(id: IdT): Unit = {}
-          override def add(draft: EntityT): EntityT = fail("add should not be used!")
+          override def update(draft: EntityT): EntityT               = draft
+          override def delete(id: IdT): Unit                         = {}
+          override def add(draft: EntityT): EntityT                  = fail("add should not be used!")
           override def getById(id: LongId[EntityT]): Option[EntityT] = fail("getById should not be used!")
-          override def isCompleted(kind: String, tag: String): Future[Boolean] = fail("isCompleted should not be used!")
+          override def isCompleted(kind: String, tag: String): Future[Boolean] =
+            fail("isCompleted should not be used!")
           override def getOne(kind: String): Future[Option[Item]] = fail("getOne should not be used!")
         }
 
@@ -67,7 +68,7 @@ class BridgeUploadQueueRepositoryAdapterSuite extends BaseSuite {
         )
 
         val item = defaultItem
-        val r = adapter.tryRetry(item).futureValue
+        val r    = adapter.tryRetry(item).futureValue
         assert(r.isDefined)
         assert(!r.contains(item))
       }
@@ -80,10 +81,11 @@ class BridgeUploadQueueRepositoryAdapterSuite extends BaseSuite {
             assert(draft.attempts === (item.attempts + 1), "repository.add")
             draft
           }
-          override def delete(id: IdT): Unit = {}
-          override def add(draft: EntityT): EntityT = fail("add should not be used!")
+          override def delete(id: IdT): Unit                         = {}
+          override def add(draft: EntityT): EntityT                  = fail("add should not be used!")
           override def getById(id: LongId[EntityT]): Option[EntityT] = fail("getById should not be used!")
-          override def isCompleted(kind: String, tag: String): Future[Boolean] = fail("isCompleted should not be used!")
+          override def isCompleted(kind: String, tag: String): Future[Boolean] =
+            fail("isCompleted should not be used!")
           override def getOne(kind: String): Future[Option[Item]] = fail("getOne should not be used!")
         }
 
@@ -104,9 +106,10 @@ class BridgeUploadQueueRepositoryAdapterSuite extends BaseSuite {
           override def delete(id: IdT): Unit = {
             assert(id == item.id, "repository.delete")
           }
-          override def add(draft: EntityT): EntityT = fail("add should not be used!")
+          override def add(draft: EntityT): EntityT                  = fail("add should not be used!")
           override def getById(id: LongId[EntityT]): Option[EntityT] = fail("getById should not be used!")
-          override def isCompleted(kind: String, tag: String): Future[Boolean] = fail("isCompleted should not be used!")
+          override def isCompleted(kind: String, tag: String): Future[Boolean] =
+            fail("isCompleted should not be used!")
           override def getOne(kind: String): Future[Option[Item]] = fail("getOne should not be used!")
         }
 
@@ -127,10 +130,11 @@ class BridgeUploadQueueRepositoryAdapterSuite extends BaseSuite {
             assert(draft.nextAttempt.isAfter(item.nextAttempt), "repository.add")
             draft
           }
-          override def delete(id: IdT): Unit = {}
-          override def add(draft: EntityT): EntityT = fail("add should not be used!")
+          override def delete(id: IdT): Unit                         = {}
+          override def add(draft: EntityT): EntityT                  = fail("add should not be used!")
           override def getById(id: LongId[EntityT]): Option[EntityT] = fail("getById should not be used!")
-          override def isCompleted(kind: String, tag: String): Future[Boolean] = fail("isCompleted should not be used!")
+          override def isCompleted(kind: String, tag: String): Future[Boolean] =
+            fail("isCompleted should not be used!")
           override def getOne(kind: String): Future[Option[Item]] = fail("getOne should not be used!")
         }
 
@@ -151,11 +155,12 @@ class BridgeUploadQueueRepositoryAdapterSuite extends BaseSuite {
 
       "should not return an item" in {
         val repository = new BridgeUploadQueueRepository {
-          override def delete(id: IdT): Unit = {}
-          override def update(entity: EntityT): EntityT = fail("update should not be used!")
-          override def add(draft: EntityT): EntityT = fail("add should not be used!")
+          override def delete(id: IdT): Unit                         = {}
+          override def update(entity: EntityT): EntityT              = fail("update should not be used!")
+          override def add(draft: EntityT): EntityT                  = fail("add should not be used!")
           override def getById(id: LongId[EntityT]): Option[EntityT] = fail("getById should not be used!")
-          override def isCompleted(kind: String, tag: String): Future[Boolean] = fail("isCompleted should not be used!")
+          override def isCompleted(kind: String, tag: String): Future[Boolean] =
+            fail("isCompleted should not be used!")
           override def getOne(kind: String): Future[Option[Item]] = fail("getOne should not be used!")
         }
 
@@ -171,11 +176,12 @@ class BridgeUploadQueueRepositoryAdapterSuite extends BaseSuite {
 
       "should not add any item to the queue" in {
         val repository = new BridgeUploadQueueRepository {
-          override def update(draft: EntityT): EntityT = throw new IllegalAccessException("add should not be called")
-          override def delete(id: IdT): Unit = {}
-          override def add(draft: EntityT): EntityT = fail("add should not be used!")
+          override def update(draft: EntityT): EntityT               = throw new IllegalAccessException("add should not be called")
+          override def delete(id: IdT): Unit                         = {}
+          override def add(draft: EntityT): EntityT                  = fail("add should not be used!")
           override def getById(id: LongId[EntityT]): Option[EntityT] = fail("getById should not be used!")
-          override def isCompleted(kind: String, tag: String): Future[Boolean] = fail("isCompleted should not be used!")
+          override def isCompleted(kind: String, tag: String): Future[Boolean] =
+            fail("isCompleted should not be used!")
           override def getOne(kind: String): Future[Option[Item]] = fail("getOne should not be used!")
         }
 
@@ -193,10 +199,11 @@ class BridgeUploadQueueRepositoryAdapterSuite extends BaseSuite {
           override def delete(id: IdT): Unit = {
             assert(id == defaultItem.id, "repository.delete")
           }
-          override def update(entity: EntityT): EntityT = fail("update should not be used!")
-          override def add(draft: EntityT): EntityT = fail("add should not be used!")
+          override def update(entity: EntityT): EntityT              = fail("update should not be used!")
+          override def add(draft: EntityT): EntityT                  = fail("add should not be used!")
           override def getById(id: LongId[EntityT]): Option[EntityT] = fail("getById should not be used!")
-          override def isCompleted(kind: String, tag: String): Future[Boolean] = fail("isCompleted should not be used!")
+          override def isCompleted(kind: String, tag: String): Future[Boolean] =
+            fail("isCompleted should not be used!")
           override def getOne(kind: String): Future[Option[Item]] = fail("getOne should not be used!")
         }
 
diff --git a/src/test/scala/xyz/driver/pdsuicommon/db/QueryBuilderParametersSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/db/QueryBuilderParametersSuite.scala
index 0748e8a..df8e417 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/db/QueryBuilderParametersSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/db/QueryBuilderParametersSuite.scala
@@ -38,7 +38,7 @@ class QueryBuilderParametersSuite extends FreeSpecLike {
 
   val queryBasis =
     s"""select `$tableName`.*
-        |from `$tableName`""".stripMargin.trim
+       |from `$tableName`""".stripMargin.trim
 
   "toSql" - {
     "should generate correct SQL query" - {
@@ -49,89 +49,120 @@ class QueryBuilderParametersSuite extends FreeSpecLike {
 
       "with filtering: " - {
         "single atom filter" in {
-          val (sql, _) = queryBuilderParameters.copy(filter = Atom.Binary("name", Eq, "x")).toSql(namingStrategy = MysqlEscape)
-          assert(sql ==
-            s"""$queryBasis
-               |where `$tableName`.`name` = ?""".stripMargin)
+          val (sql, _) =
+            queryBuilderParameters.copy(filter = Atom.Binary("name", Eq, "x")).toSql(namingStrategy = MysqlEscape)
+          assert(
+            sql ==
+              s"""$queryBasis
+                 |where `$tableName`.`name` = ?""".stripMargin)
         }
 
         "single atom filter for optional field with NotEq operation" in {
-          val (sql, _) = queryBuilderParameters.copy(filter = Atom.Binary("optionUser", NotEq, "x")).toSql(namingStrategy = MysqlEscape)
-          assert(sql ==
-            s"""$queryBasis
-               |where (`$tableName`.`optionUser` is null or `$tableName`.`optionUser` != ?)""".stripMargin)
+          val (sql, _) = queryBuilderParameters
+            .copy(filter = Atom.Binary("optionUser", NotEq, "x"))
+            .toSql(namingStrategy = MysqlEscape)
+          assert(
+            sql ==
+              s"""$queryBasis
+                 |where (`$tableName`.`optionUser` is null or `$tableName`.`optionUser` != ?)""".stripMargin)
         }
 
         "single atom filter for field with IN operation" in {
-          val (sql, _) = queryBuilderParameters.copy(filter = Atom.NAry("date", In, Seq("x", "x", "x"))).toSql(namingStrategy = MysqlEscape)
-          assert(sql ==
-            s"""$queryBasis
-               |where `$tableName`.`date` in (?, ?, ?)""".stripMargin)
+          val (sql, _) = queryBuilderParameters
+            .copy(filter = Atom.NAry("date", In, Seq("x", "x", "x")))
+            .toSql(namingStrategy = MysqlEscape)
+          assert(
+            sql ==
+              s"""$queryBasis
+                 |where `$tableName`.`date` in (?, ?, ?)""".stripMargin)
         }
 
         "multiple intersected filters" in {
-          val (sql, _) = queryBuilderParameters.copy(filter = Intersection(Seq(
-            Atom.Binary("name", Gt, "x"),
-            Atom.Binary("optionDate", GtEq, "x")
-          ))).toSql(namingStrategy = MysqlEscape)
-          assert(sql ==
-            s"""$queryBasis
-               |where (`$tableName`.`name` > ? and `$tableName`.`optionDate` >= ?)""".stripMargin)
+          val (sql, _) = queryBuilderParameters
+            .copy(
+              filter = Intersection(
+                Seq(
+                  Atom.Binary("name", Gt, "x"),
+                  Atom.Binary("optionDate", GtEq, "x")
+                )))
+            .toSql(namingStrategy = MysqlEscape)
+          assert(
+            sql ==
+              s"""$queryBasis
+                 |where (`$tableName`.`name` > ? and `$tableName`.`optionDate` >= ?)""".stripMargin)
         }
 
         "multiple intersected nested filters" in {
-          val (sql, _) = queryBuilderParameters.copy(filter = Intersection(Seq(
-            Atom.Binary("name", Gt, "x"),
-            Atom.Binary("optionDate", GtEq, "x"),
-            Intersection(Seq(
-              Atom.Binary("optionUser", Eq, "x"),
-              Atom.Binary("date", LtEq, "x")
-            ))
-          ))).toSql(namingStrategy = MysqlEscape)
-          assert(sql ==
-            s"$queryBasis\nwhere (`$tableName`.`name` > ? and `$tableName`.`optionDate` >= ?" +
-              s" and (`$tableName`.`optionUser` = ? and `$tableName`.`date` <= ?))")
+          val (sql, _) = queryBuilderParameters
+            .copy(
+              filter = Intersection(
+                Seq(
+                  Atom.Binary("name", Gt, "x"),
+                  Atom.Binary("optionDate", GtEq, "x"),
+                  Intersection(Seq(
+                    Atom.Binary("optionUser", Eq, "x"),
+                    Atom.Binary("date", LtEq, "x")
+                  ))
+                )))
+            .toSql(namingStrategy = MysqlEscape)
+          assert(
+            sql ==
+              s"$queryBasis\nwhere (`$tableName`.`name` > ? and `$tableName`.`optionDate` >= ?" +
+                s" and (`$tableName`.`optionUser` = ? and `$tableName`.`date` <= ?))")
         }
 
         "multiple unionized filters" in {
-          val (sql, _) = queryBuilderParameters.copy(filter = Union(Seq(
-            Atom.Binary("name", Gt, "x"),
-            Atom.Binary("optionDate", GtEq, "x")
-          ))).toSql(namingStrategy = MysqlEscape)
-          assert(sql ==
-            s"""$queryBasis
-               |where (`$tableName`.`name` > ? or `$tableName`.`optionDate` >= ?)""".stripMargin.trim)
+          val (sql, _) = queryBuilderParameters
+            .copy(
+              filter = Union(
+                Seq(
+                  Atom.Binary("name", Gt, "x"),
+                  Atom.Binary("optionDate", GtEq, "x")
+                )))
+            .toSql(namingStrategy = MysqlEscape)
+          assert(
+            sql ==
+              s"""$queryBasis
+                 |where (`$tableName`.`name` > ? or `$tableName`.`optionDate` >= ?)""".stripMargin.trim)
         }
 
         "multiple unionized nested filters" in {
-          val (sql, _) = queryBuilderParameters.copy(filter = Union(Seq(
-            Atom.Binary("name", Gt, "x"),
-            Atom.Binary("optionDate", GtEq, "x"),
-            Union(Seq(
-              Atom.Binary("optionUser", Eq, "x"),
-              Atom.Binary("date", LtEq, "x")
-            ))
-          ))).toSql(namingStrategy = MysqlEscape)
-          assert(sql ==
-            s"""$queryBasis
-               |where (`$tableName`.`name` > ? or `$tableName`.`optionDate` >= ? or (`$tableName`.`optionUser` = ? or `$tableName`.`date` <= ?))""".stripMargin)
+          val (sql, _) = queryBuilderParameters
+            .copy(
+              filter = Union(
+                Seq(
+                  Atom.Binary("name", Gt, "x"),
+                  Atom.Binary("optionDate", GtEq, "x"),
+                  Union(Seq(
+                    Atom.Binary("optionUser", Eq, "x"),
+                    Atom.Binary("date", LtEq, "x")
+                  ))
+                )))
+            .toSql(namingStrategy = MysqlEscape)
+          assert(
+            sql ==
+              s"""$queryBasis
+                 |where (`$tableName`.`name` > ? or `$tableName`.`optionDate` >= ? or (`$tableName`.`optionUser` = ? or `$tableName`.`date` <= ?))""".stripMargin)
         }
 
         "multiple unionized and intersected nested filters" in {
-          val (sql, _) = queryBuilderParameters.copy(filter = Union(Seq(
-            Intersection(Seq(
-              Atom.Binary("name", Gt, "x"),
-              Atom.Binary("optionDate", GtEq, "x")
-            )),
-            Intersection(Seq(
-              Atom.Binary("optionUser", Eq, "x"),
-              Atom.Binary("date", LtEq, "x")
-            ))
-          ))).toSql(namingStrategy = MysqlEscape)
-
-          assert(sql ==
-            s"$queryBasis\nwhere ((`$tableName`.`name` > ? and `$tableName`.`optionDate` >= ?) " +
-              s"or (`$tableName`.`optionUser` = ? and `$tableName`.`date` <= ?))")
+          val (sql, _) = queryBuilderParameters
+            .copy(filter = Union(Seq(
+              Intersection(Seq(
+                Atom.Binary("name", Gt, "x"),
+                Atom.Binary("optionDate", GtEq, "x")
+              )),
+              Intersection(Seq(
+                Atom.Binary("optionUser", Eq, "x"),
+                Atom.Binary("date", LtEq, "x")
+              ))
+            )))
+            .toSql(namingStrategy = MysqlEscape)
+
+          assert(
+            sql ==
+              s"$queryBasis\nwhere ((`$tableName`.`name` > ? and `$tableName`.`optionDate` >= ?) " +
+                s"or (`$tableName`.`optionUser` = ? and `$tableName`.`date` <= ?))")
         }
 
         "single field from foreign table" in {
@@ -149,98 +180,128 @@ class QueryBuilderParametersSuite extends FreeSpecLike {
 
       "with sorting:" - {
         "single field sorting" in {
-          val (sql, _) = queryBuilderParameters.copy(sorting = Dimension(None, "name", Ascending)).toSql(namingStrategy = MysqlEscape)
+          val (sql, _) = queryBuilderParameters
+            .copy(sorting = Dimension(None, "name", Ascending))
+            .toSql(namingStrategy = MysqlEscape)
 
-          assert(sql ==
-            s"""$queryBasis
-               |order by `$tableName`.`name` asc""".stripMargin)
+          assert(
+            sql ==
+              s"""$queryBasis
+                 |order by `$tableName`.`name` asc""".stripMargin)
         }
 
         "single foreign sorting field" in {
-          val (sql, _) = queryBuilderParameters.copy(sorting = Dimension(Some("Kind"), "name", Ascending)).toSql(namingStrategy = MysqlEscape)
+          val (sql, _) = queryBuilderParameters
+            .copy(sorting = Dimension(Some("Kind"), "name", Ascending))
+            .toSql(namingStrategy = MysqlEscape)
 
-          assert(sql ==
-            s"""select `$tableName`.*
-                |from `$tableName`
-                |inner join `Kind` on `Entity`.`kindId` = `Kind`.`id`
-                |order by `Kind`.`name` asc""".stripMargin)
+          assert(
+            sql ==
+              s"""select `$tableName`.*
+                 |from `$tableName`
+                 |inner join `Kind` on `Entity`.`kindId` = `Kind`.`id`
+                 |order by `Kind`.`name` asc""".stripMargin)
         }
 
         "multiple fields sorting" in {
-          val (sql, _) = queryBuilderParameters.copy(sorting = Sequential(Seq(
-            Dimension(None, "name", Ascending),
-            Dimension(None, "date", Descending)
-          ))).toSql(namingStrategy = MysqlEscape)
-          assert(sql ==
-            s"""$queryBasis
-               |order by `$tableName`.`name` asc, `$tableName`.`date` desc""".stripMargin)
+          val (sql, _) = queryBuilderParameters
+            .copy(
+              sorting = Sequential(
+                Seq(
+                  Dimension(None, "name", Ascending),
+                  Dimension(None, "date", Descending)
+                )))
+            .toSql(namingStrategy = MysqlEscape)
+          assert(
+            sql ==
+              s"""$queryBasis
+                 |order by `$tableName`.`name` asc, `$tableName`.`date` desc""".stripMargin)
         }
 
         "multiple foreign sorting field" in {
-          val (sql, _) = queryBuilderParameters.copy(sorting = Sequential(Seq(
-            Dimension(Some("Kind"), "name", Ascending),
-            Dimension(Some("User"), "name", Descending)
-          ))).toSql(namingStrategy = MysqlEscape)
+          val (sql, _) = queryBuilderParameters
+            .copy(
+              sorting = Sequential(
+                Seq(
+                  Dimension(Some("Kind"), "name", Ascending),
+                  Dimension(Some("User"), "name", Descending)
+                )))
+            .toSql(namingStrategy = MysqlEscape)
 
-          assert(sql ==
-            s"""select `$tableName`.*
-                |from `$tableName`
-                |inner join `Kind` on `$tableName`.`kindId` = `Kind`.`id`
-                |inner join `User` on `$tableName`.`optionUser` = `User`.`id`
-                |order by `Kind`.`name` asc, `User`.`name` desc""".stripMargin)
+          assert(
+            sql ==
+              s"""select `$tableName`.*
+                 |from `$tableName`
+                 |inner join `Kind` on `$tableName`.`kindId` = `Kind`.`id`
+                 |inner join `User` on `$tableName`.`optionUser` = `User`.`id`
+                 |order by `Kind`.`name` asc, `User`.`name` desc""".stripMargin)
         }
 
         "multiple field sorting (including foreign tables)" in {
-          val (sql, _) = queryBuilderParameters.copy(sorting = Sequential(Seq(
-            Dimension(Some("Kind"), "name", Ascending),
-            Dimension(None, "date", Descending)
-          ))).toSql(namingStrategy = MysqlEscape)
+          val (sql, _) = queryBuilderParameters
+            .copy(
+              sorting = Sequential(
+                Seq(
+                  Dimension(Some("Kind"), "name", Ascending),
+                  Dimension(None, "date", Descending)
+                )))
+            .toSql(namingStrategy = MysqlEscape)
 
-          assert(sql ==
-            s"""select `$tableName`.*
-                |from `$tableName`
-                |inner join `Kind` on `$tableName`.`kindId` = `Kind`.`id`
-                |order by `Kind`.`name` asc, `$tableName`.`date` desc""".stripMargin)
+          assert(
+            sql ==
+              s"""select `$tableName`.*
+                 |from `$tableName`
+                 |inner join `Kind` on `$tableName`.`kindId` = `Kind`.`id`
+                 |order by `Kind`.`name` asc, `$tableName`.`date` desc""".stripMargin)
         }
       }
 
       "with pagination" in {
-        val (sql, _) = queryBuilderParameters.copy(pagination = Some(Pagination(5, 3))).toSql(namingStrategy = MysqlEscape)
-        assert(sql ==
-          s"""$queryBasis
-             |limit 10, 5""".stripMargin)
+        val (sql, _) =
+          queryBuilderParameters.copy(pagination = Some(Pagination(5, 3))).toSql(namingStrategy = MysqlEscape)
+        assert(
+          sql ==
+            s"""$queryBasis
+               |limit 10, 5""".stripMargin)
       }
 
       "combined" in {
-        val filter = Union(Seq(
-          Intersection(Seq(
-            Atom.Binary("name", Gt, "x"),
-            Atom.Binary("optionDate", GtEq, "x")
-          )),
-          Intersection(Seq(
-            Atom.Binary("optionUser", Eq, "x"),
-            Atom.Binary("date", LtEq, "x")
+        val filter = Union(
+          Seq(
+            Intersection(
+              Seq(
+                Atom.Binary("name", Gt, "x"),
+                Atom.Binary("optionDate", GtEq, "x")
+              )),
+            Intersection(
+              Seq(
+                Atom.Binary("optionUser", Eq, "x"),
+                Atom.Binary("date", LtEq, "x")
+              ))
+          ))
+        val sorting = Sequential(
+          Seq(
+            Dimension(Some("Kind"), "name", Ascending),
+            Dimension(None, "name", Ascending),
+            Dimension(None, "date", Descending)
           ))
-        ))
-        val sorting = Sequential(Seq(
-          Dimension(Some("Kind"), "name", Ascending),
-          Dimension(None, "name", Ascending),
-          Dimension(None, "date", Descending)
-        ))
-
-        val (sql, _) = queryBuilderParameters.copy(
-          filter = filter,
-          sorting = sorting,
-          pagination = Some(Pagination(5, 3))
-        ).toSql(namingStrategy = MysqlEscape)
-
-        assert(sql ==
-          s"""select `$tableName`.*
-              |from `$tableName`
-              |inner join `Kind` on `$tableName`.`kindId` = `Kind`.`id`
-              |where ((`$tableName`.`name` > ? and `$tableName`.`optionDate` >= ?) or (`$tableName`.`optionUser` = ? and `$tableName`.`date` <= ?))
-              |order by `Kind`.`name` asc, `$tableName`.`name` asc, `$tableName`.`date` desc
-              |limit 10, 5""".stripMargin)
+
+        val (sql, _) = queryBuilderParameters
+          .copy(
+            filter = filter,
+            sorting = sorting,
+            pagination = Some(Pagination(5, 3))
+          )
+          .toSql(namingStrategy = MysqlEscape)
+
+        assert(
+          sql ==
+            s"""select `$tableName`.*
+               |from `$tableName`
+               |inner join `Kind` on `$tableName`.`kindId` = `Kind`.`id`
+               |where ((`$tableName`.`name` > ? and `$tableName`.`optionDate` >= ?) or (`$tableName`.`optionUser` = ? and `$tableName`.`date` <= ?))
+               |order by `Kind`.`name` asc, `$tableName`.`name` asc, `$tableName`.`date` desc
+               |limit 10, 5""".stripMargin)
       }
 
     }
diff --git a/src/test/scala/xyz/driver/pdsuicommon/db/SearchFilterExprSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/db/SearchFilterExprSuite.scala
index ee467af..35c8d30 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/db/SearchFilterExprSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/db/SearchFilterExprSuite.scala
@@ -6,14 +6,16 @@ class SearchFilterExprSuite extends FreeSpecLike with MustMatchers {
 
   "replace" - {
     "all entities are changed" in {
-      val ast = SearchFilterExpr.Union(Seq(
-        SearchFilterExpr.Intersection(Seq(
-          SearchFilterExpr.Atom.Binary("foo", SearchFilterBinaryOperation.Gt, "10"),
-          SearchFilterExpr.Atom.Binary("foo", SearchFilterBinaryOperation.Lt, "20")
-        )),
-        SearchFilterExpr.Atom.NAry("bar", SearchFilterNAryOperation.In, Seq("x", "y", "z")),
-        SearchFilterExpr.Atom.Binary("foo", SearchFilterBinaryOperation.Eq, "40")
-      ))
+      val ast = SearchFilterExpr.Union(
+        Seq(
+          SearchFilterExpr.Intersection(
+            Seq(
+              SearchFilterExpr.Atom.Binary("foo", SearchFilterBinaryOperation.Gt, "10"),
+              SearchFilterExpr.Atom.Binary("foo", SearchFilterBinaryOperation.Lt, "20")
+            )),
+          SearchFilterExpr.Atom.NAry("bar", SearchFilterNAryOperation.In, Seq("x", "y", "z")),
+          SearchFilterExpr.Atom.Binary("foo", SearchFilterBinaryOperation.Eq, "40")
+        ))
 
       val newAst = ast.replace {
         case x: SearchFilterExpr.Atom.Binary if x.dimension.name == "foo" =>
@@ -22,7 +24,7 @@ class SearchFilterExprSuite extends FreeSpecLike with MustMatchers {
 
       val result = newAst.find {
         case x: SearchFilterExpr.Atom.Binary => x.dimension.name == "foo"
-        case _ => false
+        case _                               => false
       }
 
       result mustBe empty
diff --git a/src/test/scala/xyz/driver/pdsuicommon/logging/PhiStringContextSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/logging/PhiStringContextSuite.scala
index f623b81..de1d1bf 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/logging/PhiStringContextSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/logging/PhiStringContextSuite.scala
@@ -23,7 +23,7 @@ class PhiStringContextSuite extends FreeSpecLike {
   )
 
   "should not contain private info" in {
-    val foo = new Foo(42, "test")
+    val foo    = new Foo(42, "test")
     val result = phi"foo is $foo".text
     assert(!result.contains("test"))
     assert(!result.contains("42"))
diff --git a/src/test/scala/xyz/driver/pdsuicommon/utils/DiffUtils.scala b/src/test/scala/xyz/driver/pdsuicommon/utils/DiffUtils.scala
index d42bca6..5338173 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/utils/DiffUtils.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/utils/DiffUtils.scala
@@ -9,9 +9,7 @@ import xyz.driver.pdsuicommon.domain.PasswordHash
 
 import scala.io.AnsiColor
 
-trait DiffUtils {
-
-  this: Assertions =>
+trait DiffUtils { this: Assertions =>
 
   def assertIdentical[T: DiffShow](left: T, right: T): Unit = {
     val diff = DiffShow.diff(left, right)
diff --git a/src/test/scala/xyz/driver/pdsuidomain/DocumentSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/DocumentSuite.scala
index 7187400..da8d6f3 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/DocumentSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/DocumentSuite.scala
@@ -13,21 +13,22 @@ class DocumentSuite extends BaseSuite {
     "can't submit invalid data" - {
       val base = sampleDocument
 
-      val now = LocalDateTime.now()
-      val past1 = now.minus(2, ChronoUnit.DAYS)
-      val past2 = past1.plus(1, ChronoUnit.DAYS)
+      val now     = LocalDateTime.now()
+      val past1   = now.minus(2, ChronoUnit.DAYS)
+      val past2   = past1.plus(1, ChronoUnit.DAYS)
       val future1 = now.plus(1, ChronoUnit.DAYS)
       val future2 = future1.plus(1, ChronoUnit.DAYS)
 
       Seq(
-        "startDate should be non-empty" -> base.copy(startDate = None),
-        "startDate should be greater, than endDate" -> base.copy(startDate = Some(past2), endDate = Some(past1)),
+        "startDate should be non-empty"               -> base.copy(startDate = None),
+        "startDate should be greater, than endDate"   -> base.copy(startDate = Some(past2), endDate = Some(past1)),
         "startDate and endDate should be in the past" -> base.copy(startDate = Some(future1), endDate = Some(future2))
-      ).foreach { case (title, orig) =>
-        s"$title" in {
-          val r = Document.validator(orig)
-          assert(r.isLeft, s"should fail, but: ${r.right}")
-        }
+      ).foreach {
+        case (title, orig) =>
+          s"$title" in {
+            val r = Document.validator(orig)
+            assert(r.isLeft, s"should fail, but: ${r.right}")
+          }
       }
     }
   }
-- 
cgit v1.2.3