Scalafmtv0.1.2v0.1.1

13 files changed, 133 insertions, 120 deletions

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)
     )
   }
 }