Latest PDS UI utils

40 files changed, 269 insertions, 206 deletions

diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/arm/ApiArm.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/arm/ApiArm.scala
index 509ea35..2185e3a 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/arm/ApiArm.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/arm/ApiArm.scala
@@ -12,7 +12,7 @@ object ApiArm {
     (JsPath \ "id").format[Long] and
       (JsPath \ "name").format[String] and
       (JsPath \ "trialId").format[String]
-    ) (ApiArm.apply, unlift(ApiArm.unapply))
+  )(ApiArm.apply, unlift(ApiArm.unapply))
 
   def fromDomain(arm: Arm): ApiArm = ApiArm(
     id = arm.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/category/ApiCategory.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/category/ApiCategory.scala
index fabdaa2..f1e15f3 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/category/ApiCategory.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/category/ApiCategory.scala
@@ -13,7 +13,7 @@ object ApiCategory {
     (JsPath \ "id").format[Long] and
       (JsPath \ "name").format[String] and
       (JsPath \ "labels").format[List[ApiLabel]]
-    ) (ApiCategory.apply, unlift(ApiCategory.unapply))
+  )(ApiCategory.apply, unlift(ApiCategory.unapply))
 
   def fromDomain(categoryWithLabels: CategoryWithLabels) = ApiCategory(
     id = categoryWithLabels.category.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiCriterion.scala
index 0f3b76e..1e7114a 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiCriterion.scala
@@ -26,7 +26,7 @@ object ApiCriterion {
       (JsPath \ "isCompound").format[Boolean] and
       (JsPath \ "labels").format(seqJsonFormat[ApiCriterionLabel]) and
       (JsPath \ "trialId").format[String]
-    ) (ApiCriterion.apply, unlift(ApiCriterion.unapply))
+  )(ApiCriterion.apply, unlift(ApiCriterion.unapply))
 
   def fromDomain(richCriterion: RichCriterion) = ApiCriterion(
     id = richCriterion.criterion.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiNewCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiNewCriterion.scala
index 85c91d5..604a98b 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiNewCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiNewCriterion.scala
@@ -37,5 +37,5 @@ object ApiNewCriterion {
       (JsPath \ "text").formatNullable[String] and
       (JsPath \ "labels").format(seqJsonFormat[ApiCriterionLabel]) and
       (JsPath \ "trialId").format[String]
-    ) (ApiNewCriterion.apply, unlift(ApiNewCriterion.unapply))
+  )(ApiNewCriterion.apply, unlift(ApiNewCriterion.unapply))
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiUpdateCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiUpdateCriterion.scala
index c73c3ef..2bcda56 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiUpdateCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiUpdateCriterion.scala
@@ -34,15 +34,19 @@ final case class ApiUpdateCriterion(meta: Tristate[String],
 object ApiUpdateCriterion {
 
   private val reads: Reads[ApiUpdateCriterion] = (
-    (JsPath \ "meta").readTristate(Reads { x => JsSuccess(Json.stringify(x)) }).map {
-      case Tristate.Present("{}") => Tristate.Absent
-      case x => x
-    } and
+    (JsPath \ "meta")
+      .readTristate(Reads { x =>
+        JsSuccess(Json.stringify(x))
+      })
+      .map {
+        case Tristate.Present("{}") => Tristate.Absent
+        case x                      => x
+      } and
       (JsPath \ "arms").readTristate(seqJsonFormat[Long]) and
       (JsPath \ "text").readNullable[String] and
       (JsPath \ "isCompound").readNullable[Boolean] and
       (JsPath \ "labels").readTristate(seqJsonFormat[ApiCriterionLabel])
-    ) (ApiUpdateCriterion.apply _)
+  )(ApiUpdateCriterion.apply _)
 
   private val writes: Writes[ApiUpdateCriterion] = (
     (JsPath \ "meta").writeTristate(Writes[String](Json.parse)) and
@@ -50,7 +54,7 @@ object ApiUpdateCriterion {
       (JsPath \ "text").writeNullable[String] and
       (JsPath \ "isCompound").writeNullable[Boolean] and
       (JsPath \ "labels").writeTristate(seqJsonFormat[ApiCriterionLabel])
-    ) (unlift(ApiUpdateCriterion.unapply))
+  )(unlift(ApiUpdateCriterion.unapply))
 
   implicit val format: Format[ApiUpdateCriterion] = Format(reads, writes)
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocument.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocument.scala
index be9c65b..0fd96b3 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocument.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocument.scala
@@ -28,7 +28,7 @@ object ApiDocument {
   private val statusFormat = Format(
     Reads.StringReads.filter(ValidationError("unknown status")) {
       case x if DocumentUtils.statusFromString.isDefinedAt(x) => true
-      case _ => false
+      case _                                                  => false
     },
     Writes.StringWrites
   )
@@ -47,8 +47,10 @@ object ApiDocument {
       (JsPath \ "previousStatus").formatNullable(statusFormat) and
       (JsPath \ "assignee").formatNullable[Long] and
       (JsPath \ "previousAssignee").formatNullable[Long] and
-      (JsPath \ "meta").formatNullable(Format(Reads { x => JsSuccess(Json.stringify(x)) }, Writes[String](Json.parse)))
-    ) (ApiDocument.apply, unlift(ApiDocument.unapply))
+      (JsPath \ "meta").formatNullable(Format(Reads { x =>
+        JsSuccess(Json.stringify(x))
+      }, Writes[String](Json.parse)))
+  )(ApiDocument.apply, unlift(ApiDocument.unapply))
 
   def fromDomain(document: Document): ApiDocument = {
     ApiDocument(
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocumentType.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocumentType.scala
index e00da20..8b11b91 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocumentType.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocumentType.scala
@@ -11,7 +11,7 @@ object ApiDocumentType {
   implicit val format: Format[ApiDocumentType] = (
     (JsPath \ "id").format[Long] and
       (JsPath \ "name").format[String]
-    ) (ApiDocumentType.apply, unlift(ApiDocumentType.unapply))
+  )(ApiDocumentType.apply, unlift(ApiDocumentType.unapply))
 
   def fromDomain(documentType: DocumentType) = ApiDocumentType(
     id = documentType.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiProviderType.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiProviderType.scala
index 7b370ba..eb0ac46 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiProviderType.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiProviderType.scala
@@ -11,7 +11,7 @@ object ApiProviderType {
   implicit val format: Format[ApiProviderType] = (
     (JsPath \ "id").format[Long] and
       (JsPath \ "name").format[String]
-    ) (ApiProviderType.apply, unlift(ApiProviderType.unapply))
+  )(ApiProviderType.apply, unlift(ApiProviderType.unapply))
 
   def fromDomain(providerType: ProviderType) = ApiProviderType(
     id = providerType.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/DocumentUtils.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/DocumentUtils.scala
index 87e449f..24e388e 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/DocumentUtils.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/DocumentUtils.scala
@@ -5,20 +5,20 @@ import xyz.driver.pdsuidomain.entities.Document.Status
 object DocumentUtils {
 
   val statusFromString: PartialFunction[String, Status] = {
-    case "New" => Status.New
+    case "New"       => Status.New
     case "Organized" => Status.Organized
     case "Extracted" => Status.Extracted
-    case "Done" => Status.Done
-    case "Flagged" => Status.Flagged
-    case "Archived" => Status.Archived
+    case "Done"      => Status.Done
+    case "Flagged"   => Status.Flagged
+    case "Archived"  => Status.Archived
   }
 
   def statusToString(x: Status): String = x match {
-    case Status.New => "New"
+    case Status.New       => "New"
     case Status.Organized => "Organized"
     case Status.Extracted => "Extracted"
-    case Status.Done => "Done"
-    case Status.Flagged => "Flagged"
-    case Status.Archived => "Archived"
+    case Status.Done      => "Done"
+    case Status.Flagged   => "Flagged"
+    case Status.Archived  => "Archived"
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/extracteddata/ApiExtractedData.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/extracteddata/ApiExtractedData.scala
index dad7a1e..ec4185f 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/extracteddata/ApiExtractedData.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/extracteddata/ApiExtractedData.scala
@@ -26,12 +26,17 @@ object ApiExtractedData {
       (JsPath \ "keywordId").formatNullable[Long] and
       (JsPath \ "evidence").formatNullable[String] and
       (JsPath \ "meta").formatNullable[String] and
-      (JsPath \ "labels").formatNullable[List[ApiExtractedDataLabel]](Format(
-        Reads.of[List[ApiExtractedDataLabel]].filter(ValidationError("empty labels"))({
-          case x if x.nonEmpty => true
-          case _ => false
-        }), Writes.of[List[ApiExtractedDataLabel]]))
-    ) (ApiExtractedData.apply, unlift(ApiExtractedData.unapply))
+      (JsPath \ "labels").formatNullable[List[ApiExtractedDataLabel]](
+        Format(
+          Reads
+            .of[List[ApiExtractedDataLabel]]
+            .filter(ValidationError("empty labels"))({
+              case x if x.nonEmpty => true
+              case _               => false
+            }),
+          Writes.of[List[ApiExtractedDataLabel]]
+        ))
+  )(ApiExtractedData.apply, unlift(ApiExtractedData.unapply))
 
   def fromDomain(extractedDataWithLabels: RichExtractedData) = ApiExtractedData(
     id = extractedDataWithLabels.extractedData.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/extracteddata/ApiPartialExtractedData.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/extracteddata/ApiPartialExtractedData.scala
index 69b5627..cfd55fd 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/extracteddata/ApiPartialExtractedData.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/extracteddata/ApiPartialExtractedData.scala
@@ -66,7 +66,7 @@ object ApiPartialExtractedData {
       (JsPath \ "evidence").readTristate[String] and
       (JsPath \ "meta").readTristate[String] and
       (JsPath \ "labels").readTristate[List[ApiExtractedDataLabel]]
-    ) (ApiPartialExtractedData.apply _)
+  )(ApiPartialExtractedData.apply _)
 
   private val writes: Writes[ApiPartialExtractedData] = (
     (JsPath \ "documentId").writeNullable[Long] and
@@ -74,7 +74,7 @@ object ApiPartialExtractedData {
       (JsPath \ "evidence").writeTristate[String] and
       (JsPath \ "meta").writeTristate[String] and
       (JsPath \ "labels").writeTristate[List[ApiExtractedDataLabel]]
-    ) (unlift(ApiPartialExtractedData.unapply))
+  )(unlift(ApiPartialExtractedData.unapply))
 
   implicit val format: Format[ApiPartialExtractedData] = Format(reads, writes)
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/hypothesis/ApiHypothesis.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/hypothesis/ApiHypothesis.scala
index 0d6763c..7446ec3 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/hypothesis/ApiHypothesis.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/hypothesis/ApiHypothesis.scala
@@ -15,7 +15,7 @@ object ApiHypothesis {
       (JsPath \ "name").format[String] and
       (JsPath \ "treatmentType").format[String] and
       (JsPath \ "description").format[String]
-    ) (ApiHypothesis.apply, unlift(ApiHypothesis.unapply))
+  )(ApiHypothesis.apply, unlift(ApiHypothesis.unapply))
 
   def fromDomain(hypothesis: Hypothesis) = ApiHypothesis(
     id = hypothesis.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention/ApiIntervention.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention/ApiIntervention.scala
index 37a9758..39e0000 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention/ApiIntervention.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention/ApiIntervention.scala
@@ -22,7 +22,7 @@ object ApiIntervention {
       (JsPath \ "isActive").format[Boolean] and
       (JsPath \ "arms").format[List[Long]] and
       (JsPath \ "trialId").format[String]
-    ) (ApiIntervention.apply, unlift(ApiIntervention.unapply))
+  )(ApiIntervention.apply, unlift(ApiIntervention.unapply))
 
   def fromDomain(interventionWithArms: InterventionWithArms): ApiIntervention = {
     import interventionWithArms.intervention
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention/ApiInterventionType.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention/ApiInterventionType.scala
index ca444eb..54d2cb7 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention/ApiInterventionType.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention/ApiInterventionType.scala
@@ -11,7 +11,7 @@ object ApiInterventionType {
   implicit val format: Format[ApiInterventionType] = (
     (JsPath \ "id").format[Long] and
       (JsPath \ "name").format[String]
-    ) (ApiInterventionType.apply, unlift(ApiInterventionType.unapply))
+  )(ApiInterventionType.apply, unlift(ApiInterventionType.unapply))
 
   def fromDomain(interventionType: InterventionType) = ApiInterventionType(
     id = interventionType.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention/ApiPartialIntervention.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention/ApiPartialIntervention.scala
index 416237a..f67ba6b 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention/ApiPartialIntervention.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention/ApiPartialIntervention.scala
@@ -12,7 +12,7 @@ final case class ApiPartialIntervention(typeId: Option[Long],
 
   def applyTo(orig: InterventionWithArms): InterventionWithArms = {
     val origIntervention = orig.intervention
-    val draftArmList = arms.map(_.map(x => InterventionArm(LongId(x), orig.intervention.id)))
+    val draftArmList     = arms.map(_.map(x => InterventionArm(LongId(x), orig.intervention.id)))
     orig.copy(
       intervention = origIntervention.copy(
         typeId = typeId.map(LongId(_)).orElse(origIntervention.typeId),
@@ -31,14 +31,14 @@ object ApiPartialIntervention {
       (JsPath \ "description").readNullable[String] and
       (JsPath \ "isActive").readNullable[Boolean] and
       (JsPath \ "arms").readNullable[List[Long]]
-    ) (ApiPartialIntervention.apply _)
+  )(ApiPartialIntervention.apply _)
 
   private val writes: Writes[ApiPartialIntervention] = (
     (JsPath \ "typeId").writeNullable[Long] and
       (JsPath \ "description").writeNullable[String] and
       (JsPath \ "isActive").writeNullable[Boolean] and
       (JsPath \ "arms").writeNullable[List[Long]]
-    ) (unlift(ApiPartialIntervention.unapply))
+  )(unlift(ApiPartialIntervention.unapply))
 
   implicit val format: Format[ApiPartialIntervention] = Format(reads, writes)
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/keyword/ApiKeyword.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/keyword/ApiKeyword.scala
index afd012d..a9d02fc 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/keyword/ApiKeyword.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/keyword/ApiKeyword.scala
@@ -13,7 +13,7 @@ object ApiKeyword {
     (JsPath \ "id").format[Long] and
       (JsPath \ "keyword").format[String] and
       (JsPath \ "labels").format[List[ApiLabel]]
-    ) (ApiKeyword.apply, unlift(ApiKeyword.unapply))
+  )(ApiKeyword.apply, unlift(ApiKeyword.unapply))
 
   def fromDomain(keywordWithLabels: KeywordWithLabels) = ApiKeyword(
     id = keywordWithLabels.keyword.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiCriterionLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiCriterionLabel.scala
index 2788bf2..7a65af8 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiCriterionLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiCriterionLabel.scala
@@ -21,7 +21,7 @@ final case class ApiCriterionLabel(labelId: Option[Long],
     categoryId = categoryId.map(LongId[Category]),
     value = value.map {
       case "Yes" => true
-      case "No" => false
+      case "No"  => false
     },
     isDefining = isDefining
   )
@@ -41,9 +41,13 @@ object ApiCriterionLabel {
   implicit val format: Format[ApiCriterionLabel] = (
     (JsPath \ "labelId").formatNullable[Long] and
       (JsPath \ "categoryId").formatNullable[Long] and
-      (JsPath \ "value").formatNullable[String](Format(Reads.of[String].filter(ValidationError("unknown value"))({ x =>
-        x == "Yes" || x == "No"
-      }), Writes.of[String])) and
+      (JsPath \ "value").formatNullable[String](
+        Format(Reads
+                 .of[String]
+                 .filter(ValidationError("unknown value"))({ x =>
+                   x == "Yes" || x == "No"
+                 }),
+               Writes.of[String])) and
       (JsPath \ "isDefining").format[Boolean]
-    ) (ApiCriterionLabel.apply, unlift(ApiCriterionLabel.unapply))
+  )(ApiCriterionLabel.apply, unlift(ApiCriterionLabel.unapply))
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiExtractedDataLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiExtractedDataLabel.scala
index 9159d27..cb45025 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiExtractedDataLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiExtractedDataLabel.scala
@@ -22,11 +22,15 @@ object ApiExtractedDataLabel {
   implicit val format: Format[ApiExtractedDataLabel] = (
     (JsPath \ "id").formatNullable[Long] and
       (JsPath \ "categoryId").formatNullable[Long] and
-      (JsPath \ "value").formatNullable[String](Format(Reads.of[String].filter(ValidationError("unknown value"))({
-        case x if FuzzyValue.fromString.isDefinedAt(x) => true
-        case _ => false
-      }), Writes.of[String]))
-    ) (ApiExtractedDataLabel.apply, unlift(ApiExtractedDataLabel.unapply))
+      (JsPath \ "value").formatNullable[String](
+        Format(Reads
+                 .of[String]
+                 .filter(ValidationError("unknown value"))({
+                   case x if FuzzyValue.fromString.isDefinedAt(x) => true
+                   case _                                         => false
+                 }),
+               Writes.of[String]))
+  )(ApiExtractedDataLabel.apply, unlift(ApiExtractedDataLabel.unapply))
 
   def fromDomain(dataLabel: ExtractedDataLabel) = ApiExtractedDataLabel(
     id = dataLabel.labelId.map(_.id),
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiLabel.scala
index 8c30f3a..042b380 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiLabel.scala
@@ -12,7 +12,7 @@ object ApiLabel {
     (JsPath \ "id").format[Long] and
       (JsPath \ "name").format[String] and
       (JsPath \ "categoryId").format[Long]
-    ) (ApiLabel.apply, unlift(ApiLabel.unapply))
+  )(ApiLabel.apply, unlift(ApiLabel.unapply))
 
   def fromDomain(x: Label) = ApiLabel(
     id = x.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/message/ApiMessage.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/message/ApiMessage.scala
index 20b2607..05f9564 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/message/ApiMessage.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/message/ApiMessage.scala
@@ -55,5 +55,5 @@ object ApiMessage {
       (JsPath \ "evidence").formatNullable[String] and
       (JsPath \ "archiveRequired").formatNullable[Boolean] and
       (JsPath \ "meta").formatNullable[String]
-    ) (ApiMessage.apply, unlift(ApiMessage.unapply))
+  )(ApiMessage.apply, unlift(ApiMessage.unapply))
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/message/ApiPartialMessage.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/message/ApiPartialMessage.scala
index 151234c..8c390e7 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/message/ApiPartialMessage.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/message/ApiPartialMessage.scala
@@ -66,7 +66,7 @@ object ApiPartialMessage {
       (JsPath \ "evidence").formatNullable[String] and
       (JsPath \ "archiveRequired").formatNullable[Boolean] and
       (JsPath \ "meta").formatNullable[String]
-    ) (ApiPartialMessage.apply, unlift(ApiPartialMessage.unapply))
+  )(ApiPartialMessage.apply, unlift(ApiPartialMessage.unapply))
 
   def fromDomain(domain: Message) = ApiPartialMessage(
     text = Some(domain.text),
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/ApiPatient.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/ApiPatient.scala
index 0a3938c..caa556b 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/ApiPatient.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/ApiPatient.scala
@@ -28,7 +28,7 @@ object ApiPatient {
       (JsPath \ "previousAssignee").formatNullable[Long] and
       (JsPath \ "lastUpdate").format[ZonedDateTime] and
       (JsPath \ "condition").format[String]
-    ) (ApiPatient.apply, unlift(ApiPatient.unapply))
+  )(ApiPatient.apply, unlift(ApiPatient.unapply))
 
   def fromDomain(patient: Patient) = ApiPatient(
     id = patient.id.toString,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/PatientStatus.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/PatientStatus.scala
index d906fc6..a23a1de 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/PatientStatus.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/PatientStatus.scala
@@ -5,20 +5,20 @@ import xyz.driver.pdsuidomain.entities.Patient.Status
 object PatientStatus {
 
   val statusFromString: PartialFunction[String, Status] = {
-    case "New" => Status.New
+    case "New"      => Status.New
     case "Verified" => Status.Verified
     case "Reviewed" => Status.Reviewed
-    case "Curated" => Status.Curated
-    case "Flagged" => Status.Flagged
-    case "Done" => Status.Done
+    case "Curated"  => Status.Curated
+    case "Flagged"  => Status.Flagged
+    case "Done"     => Status.Done
   }
 
   def statusToString(x: Status): String = x match {
-    case Status.New => "New"
+    case Status.New      => "New"
     case Status.Verified => "Verified"
     case Status.Reviewed => "Reviewed"
-    case Status.Curated => "Curated"
-    case Status.Flagged => "Flagged"
-    case Status.Done => "Done"
+    case Status.Curated  => "Curated"
+    case Status.Flagged  => "Flagged"
+    case Status.Done     => "Done"
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/eligible/ApiPatientEligibleTrial.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/eligible/ApiPatientEligibleTrial.scala
index c1a6e76..42c3259 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/eligible/ApiPatientEligibleTrial.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/eligible/ApiPatientEligibleTrial.scala
@@ -26,12 +26,17 @@ object ApiPatientEligibleTrial {
       (JsPath \ "trialTitle").format[String] and
       (JsPath \ "arms").format[List[String]] and
       (JsPath \ "hypothesisId").format[UUID] and
-      (JsPath \ "eligibilityStatus").formatNullable[String](Format(Reads.of[String].filter(ValidationError("unknown eligibility status"))({
-        case x if FuzzyValue.fromString.isDefinedAt(x) => true
-        case _ => false
-      }), Writes.of[String])) and
+      (JsPath \ "eligibilityStatus").formatNullable[String](Format(
+        Reads
+          .of[String]
+          .filter(ValidationError("unknown eligibility status"))({
+            case x if FuzzyValue.fromString.isDefinedAt(x) => true
+            case _                                         => false
+          }),
+        Writes.of[String]
+      )) and
       (JsPath \ "isVerified").format[Boolean]
-    ) (ApiPatientEligibleTrial.apply, unlift(ApiPatientEligibleTrial.unapply))
+  )(ApiPatientEligibleTrial.apply, unlift(ApiPatientEligibleTrial.unapply))
 
   def fromDomain(eligibleTrialWithTrial: RichPatientEligibleTrial) = ApiPatientEligibleTrial(
     id = eligibleTrialWithTrial.group.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/hypothesis/ApiPatientHypothesis.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/hypothesis/ApiPatientHypothesis.scala
index 1b0767d..374370e 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/hypothesis/ApiPatientHypothesis.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/hypothesis/ApiPatientHypothesis.scala
@@ -20,7 +20,7 @@ object ApiPatientHypothesis {
       (JsPath \ "hypothesisId").format[UUID] and
       (JsPath \ "matchedTrials").format[Long] and
       (JsPath \ "rationale").formatNullable[String]
-    ) (ApiPatientHypothesis.apply, unlift(ApiPatientHypothesis.unapply))
+  )(ApiPatientHypothesis.apply, unlift(ApiPatientHypothesis.unapply))
 
   def fromDomain(patientHypothesis: PatientHypothesis) = ApiPatientHypothesis(
     id = patientHypothesis.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPartialPatientLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPartialPatientLabel.scala
index 82e3a3f..40f7de4 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPartialPatientLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPartialPatientLabel.scala
@@ -8,13 +8,13 @@ import play.api.libs.functional.syntax._
 import play.api.libs.json._
 import xyz.driver.pdsuicommon.domain.FuzzyValue
 
-final case class ApiPartialPatientLabel(primaryValue: Option[String],
-                                        verifiedPrimaryValue: Tristate[String]) {
+final case class ApiPartialPatientLabel(primaryValue: Option[String], verifiedPrimaryValue: Tristate[String]) {
 
   def applyTo(orig: PatientLabel): PatientLabel = {
     orig.copy(
       primaryValue = primaryValue.map(FuzzyValue.fromString).orElse(orig.primaryValue),
-      verifiedPrimaryValue = verifiedPrimaryValue.cata(x => Some(FuzzyValue.fromString(x)), None, orig.verifiedPrimaryValue)
+      verifiedPrimaryValue =
+        verifiedPrimaryValue.cata(x => Some(FuzzyValue.fromString(x)), None, orig.verifiedPrimaryValue)
     )
   }
 
@@ -23,16 +23,24 @@ final case class ApiPartialPatientLabel(primaryValue: Option[String],
 object ApiPartialPatientLabel {
 
   implicit val format: Format[ApiPartialPatientLabel] = (
-    (JsPath \ "primaryValue").formatNullable[String](Format(
-        Reads.of[String].filter(ValidationError("unknown primary value"))({
-          case x if FuzzyValue.fromString.isDefinedAt(x) => true
-          case _ => false
-        }), Writes.of[String])) and
-      (JsPath \ "verifiedPrimaryValue").formatTristate[String](Format(
-        Reads.of[String].filter(ValidationError("unknown verified primary value"))({
-          case x if FuzzyValue.fromString.isDefinedAt(x) => true
-          case _ => false
-        }), Writes.of[String]))
-    ) (ApiPartialPatientLabel.apply, unlift(ApiPartialPatientLabel.unapply))
+    (JsPath \ "primaryValue").formatNullable[String](
+      Format(Reads
+               .of[String]
+               .filter(ValidationError("unknown primary value"))({
+                 case x if FuzzyValue.fromString.isDefinedAt(x) => true
+                 case _                                         => false
+               }),
+             Writes.of[String])) and
+      (JsPath \ "verifiedPrimaryValue").formatTristate[String](
+        Format(
+          Reads
+            .of[String]
+            .filter(ValidationError("unknown verified primary value"))({
+              case x if FuzzyValue.fromString.isDefinedAt(x) => true
+              case _                                         => false
+            }),
+          Writes.of[String]
+        ))
+  )(ApiPartialPatientLabel.apply, unlift(ApiPartialPatientLabel.unapply))
 
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPatientLabelDefiningCriteria.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPatientLabelDefiningCriteria.scala
index 3fe135e..ae64c33 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPatientLabelDefiningCriteria.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPatientLabelDefiningCriteria.scala
@@ -12,11 +12,15 @@ object ApiPatientLabelDefiningCriteria {
 
   implicit val format: Format[ApiPatientLabelDefiningCriteria] = (
     (JsPath \ "labelId").format[Long] and
-      (JsPath \ "value").formatNullable[String](Format(Reads.of[String].filter(ValidationError("unknown value"))({
-        case x if FuzzyValue.fromString.isDefinedAt(x) => true
-        case _ => false
-      }), Writes.of[String]))
-    ) (ApiPatientLabelDefiningCriteria.apply, unlift(ApiPatientLabelDefiningCriteria.unapply))
+      (JsPath \ "value").formatNullable[String](
+        Format(Reads
+                 .of[String]
+                 .filter(ValidationError("unknown value"))({
+                   case x if FuzzyValue.fromString.isDefinedAt(x) => true
+                   case _                                         => false
+                 }),
+               Writes.of[String]))
+  )(ApiPatientLabelDefiningCriteria.apply, unlift(ApiPatientLabelDefiningCriteria.unapply))
 
   def fromDomain(x: PatientLabel) = ApiPatientLabelDefiningCriteria(
     labelId = x.labelId.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPartialPatientCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPartialPatientCriterion.scala
index b68dad5..399bc7d 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPartialPatientCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPartialPatientCriterion.scala
@@ -9,16 +9,13 @@ import play.api.libs.json.{Format, JsPath, Reads, Writes}
 import xyz.driver.pdsuicommon.domain.FuzzyValue
 
 final case class ApiPartialPatientCriterion(eligibilityStatus: Option[String],
-                                            verifiedEligibilityStatus: Tristate[String])  {
+                                            verifiedEligibilityStatus: Tristate[String]) {
 
   def applyTo(orig: PatientCriterion): PatientCriterion = {
     orig.copy(
       eligibilityStatus = eligibilityStatus.map(FuzzyValue.fromString).orElse(orig.eligibilityStatus),
-      verifiedEligibilityStatus = verifiedEligibilityStatus.cata(x =>
-        Some(FuzzyValue.fromString(x)),
-        None,
-        orig.verifiedEligibilityStatus
-      )
+      verifiedEligibilityStatus =
+        verifiedEligibilityStatus.cata(x => Some(FuzzyValue.fromString(x)), None, orig.verifiedEligibilityStatus)
     )
   }
 }
@@ -26,15 +23,25 @@ final case class ApiPartialPatientCriterion(eligibilityStatus: Option[String],
 object ApiPartialPatientCriterion {
 
   implicit val format: Format[ApiPartialPatientCriterion] = (
-    (JsPath \ "eligibilityStatus").formatNullable[String](Format(
-      Reads.of[String].filter(ValidationError("unknown eligibility status"))({
-        case x if FuzzyValue.fromString.isDefinedAt(x) => true
-        case _ => false
-      }), Writes.of[String])) and
-      (JsPath \ "verifiedEligibilityStatus").formatTristate[String](Format(
-        Reads.of[String].filter(ValidationError("unknown verified eligibility status"))({
-          case x if FuzzyValue.fromString.isDefinedAt(x) => true
-          case _ => false
-        }), Writes.of[String]))
-    ) (ApiPartialPatientCriterion.apply, unlift(ApiPartialPatientCriterion.unapply))
+    (JsPath \ "eligibilityStatus").formatNullable[String](
+      Format(
+        Reads
+          .of[String]
+          .filter(ValidationError("unknown eligibility status"))({
+            case x if FuzzyValue.fromString.isDefinedAt(x) => true
+            case _                                         => false
+          }),
+        Writes.of[String]
+      )) and
+      (JsPath \ "verifiedEligibilityStatus").formatTristate[String](
+        Format(
+          Reads
+            .of[String]
+            .filter(ValidationError("unknown verified eligibility status"))({
+              case x if FuzzyValue.fromString.isDefinedAt(x) => true
+              case _                                         => false
+            }),
+          Writes.of[String]
+        ))
+  )(ApiPartialPatientCriterion.apply, unlift(ApiPartialPatientCriterion.unapply))
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPartialPatientCriterionList.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPartialPatientCriterionList.scala
index 71cb58f..4b08970 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPartialPatientCriterionList.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPartialPatientCriterionList.scala
@@ -8,8 +8,8 @@ import play.api.libs.json.{Format, JsPath, Reads, Writes}
 import xyz.driver.pdsuidomain.services.PatientCriterionService.DraftPatientCriterion
 
 final case class ApiPartialPatientCriterionList(id: Long,
-                                          eligibilityStatus: Option[String],
-                                          isVerified: Option[Boolean]) {
+                                                eligibilityStatus: Option[String],
+                                                isVerified: Option[Boolean]) {
 
   def toDomain: DraftPatientCriterion = DraftPatientCriterion(
     id = LongId[PatientCriterion](id),
@@ -23,10 +23,14 @@ object ApiPartialPatientCriterionList {
   implicit val format: Format[ApiPartialPatientCriterionList] = (
     (JsPath \ "id").format[Long] and
       (JsPath \ "eligibilityStatus").formatNullable[String](Format(
-        Reads.of[String].filter(ValidationError("unknown eligibility status"))({
-        case x if FuzzyValue.fromString.isDefinedAt(x) => true
-        case _ => false
-      }), Writes.of[String])) and
+        Reads
+          .of[String]
+          .filter(ValidationError("unknown eligibility status"))({
+            case x if FuzzyValue.fromString.isDefinedAt(x) => true
+            case _                                         => false
+          }),
+        Writes.of[String]
+      )) and
       (JsPath \ "isVerified").formatNullable[Boolean]
-    ) (ApiPartialPatientCriterionList.apply, unlift(ApiPartialPatientCriterionList.unapply))
+  )(ApiPartialPatientCriterionList.apply, unlift(ApiPartialPatientCriterionList.unapply))
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiCreateRecord.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiCreateRecord.scala
index 57c030b..cee67b2 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiCreateRecord.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiCreateRecord.scala
@@ -7,10 +7,7 @@ import xyz.driver.pdsuicommon.domain._
 import xyz.driver.pdsuidomain.entities._
 import play.api.libs.json._
 
-final case class ApiCreateRecord(disease: String,
-                                 patientId: String,
-                                 requestId: UUID,
-                                 filename: String) {
+final case class ApiCreateRecord(disease: String, patientId: String, requestId: UUID, filename: String) {
 
   def toDomain = MedicalRecord(
     id = LongId(0),
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiRecord.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiRecord.scala
index 6096006..de54a9e 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiRecord.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiRecord.scala
@@ -24,7 +24,7 @@ object ApiRecord {
   private val statusFormat = Format(
     Reads.StringReads.filter(ValidationError("unknown status")) {
       case x if MedicalRecordStatus.statusFromString.isDefinedAt(x) => true
-      case _ => false
+      case _                                                        => false
     },
     Writes.StringWrites
   )
@@ -39,8 +39,10 @@ object ApiRecord {
       (JsPath \ "previousStatus").formatNullable(statusFormat) and
       (JsPath \ "assignee").formatNullable[Long] and
       (JsPath \ "previousAssignee").formatNullable[Long] and
-      (JsPath \ "meta").format(Format(Reads { x => JsSuccess(Json.stringify(x)) }, Writes[String](Json.parse)))
-    ) (ApiRecord.apply, unlift(ApiRecord.unapply))
+      (JsPath \ "meta").format(Format(Reads { x =>
+        JsSuccess(Json.stringify(x))
+      }, Writes[String](Json.parse)))
+  )(ApiRecord.apply, unlift(ApiRecord.unapply))
 
   def fromDomain(record: MedicalRecord) = ApiRecord(
     id = record.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiUpdateRecord.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiUpdateRecord.scala
index b752a4c..0d17b66 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiUpdateRecord.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiUpdateRecord.scala
@@ -10,9 +10,7 @@ import play.api.libs.functional.syntax._
 import play.api.libs.json._
 import xyz.driver.pdsuicommon.json.JsonSerializer
 
-final case class ApiUpdateRecord(status: Option[String],
-                                 assignee: Tristate[Long],
-                                 meta: Tristate[String]) {
+final case class ApiUpdateRecord(status: Option[String], assignee: Tristate[Long], meta: Tristate[String]) {
 
   def applyTo(orig: MedicalRecord): MedicalRecord = {
     orig.copy(
@@ -26,22 +24,29 @@ final case class ApiUpdateRecord(status: Option[String],
 object ApiUpdateRecord {
 
   private val reads: Reads[ApiUpdateRecord] = (
-    (JsPath \ "status").readNullable[String](Reads.of[String].filter(ValidationError("unknown status"))({
-      case x if MedicalRecordStatus.statusFromString.isDefinedAt(x) => true
-      case _ => false
-    })) and
+    (JsPath \ "status").readNullable[String](
+      Reads
+        .of[String]
+        .filter(ValidationError("unknown status"))({
+          case x if MedicalRecordStatus.statusFromString.isDefinedAt(x) => true
+          case _                                                        => false
+        })) and
       (JsPath \ "assignee").readTristate[Long] and
-      (JsPath \ "meta").readTristate(Reads { x => JsSuccess(Json.stringify(x)) }).map {
-        case Tristate.Present("{}") => Tristate.Absent
-        case x => x
-      }
-    ) (ApiUpdateRecord.apply _)
+      (JsPath \ "meta")
+        .readTristate(Reads { x =>
+          JsSuccess(Json.stringify(x))
+        })
+        .map {
+          case Tristate.Present("{}") => Tristate.Absent
+          case x                      => x
+        }
+  )(ApiUpdateRecord.apply _)
 
   private val writes: Writes[ApiUpdateRecord] = (
     (JsPath \ "status").writeNullable[String] and
       (JsPath \ "assignee").writeTristate[Long] and
       (JsPath \ "meta").writeTristate(Writes[String](Json.parse))
-    ) (unlift(ApiUpdateRecord.unapply))
+  )(unlift(ApiUpdateRecord.unapply))
 
   implicit val format: Format[ApiUpdateRecord] = Format(reads, writes)
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/MedicalRecordStatus.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/MedicalRecordStatus.scala
index bde4af0..a77b76b 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/MedicalRecordStatus.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/MedicalRecordStatus.scala
@@ -5,30 +5,30 @@ import xyz.driver.pdsuidomain.entities.MedicalRecord.Status
 object MedicalRecordStatus {
 
   val statusFromString: PartialFunction[String, Status] = {
-    case "Unprocessed" => Status.Unprocessed
-    case "PreCleaning" => Status.PreCleaning
-    case "New" => Status.New
-    case "Cleaned" => Status.Cleaned
-    case "PreOrganized" => Status.PreOrganized
+    case "Unprocessed"   => Status.Unprocessed
+    case "PreCleaning"   => Status.PreCleaning
+    case "New"           => Status.New
+    case "Cleaned"       => Status.Cleaned
+    case "PreOrganized"  => Status.PreOrganized
     case "PreOrganizing" => Status.PreOrganizing
-    case "Reviewed" => Status.Reviewed
-    case "Organized" => Status.Organized
-    case "Done" => Status.Done
-    case "Flagged" => Status.Flagged
-    case "Archived" => Status.Archived
+    case "Reviewed"      => Status.Reviewed
+    case "Organized"     => Status.Organized
+    case "Done"          => Status.Done
+    case "Flagged"       => Status.Flagged
+    case "Archived"      => Status.Archived
   }
 
   def statusToString(x: Status): String = x match {
-    case Status.Unprocessed => "Unprocessed"
-    case Status.PreCleaning => "PreCleaning"
-    case Status.New => "New"
-    case Status.Cleaned => "Cleaned"
-    case Status.PreOrganized => "PreOrganized"
+    case Status.Unprocessed   => "Unprocessed"
+    case Status.PreCleaning   => "PreCleaning"
+    case Status.New           => "New"
+    case Status.Cleaned       => "Cleaned"
+    case Status.PreOrganized  => "PreOrganized"
     case Status.PreOrganizing => "PreOrganizing"
-    case Status.Reviewed => "Reviewed"
-    case Status.Organized => "Organized"
-    case Status.Done => "Done"
-    case Status.Flagged => "Flagged"
-    case Status.Archived => "Archived"
+    case Status.Reviewed      => "Reviewed"
+    case Status.Organized     => "Organized"
+    case Status.Done          => "Done"
+    case Status.Flagged       => "Flagged"
+    case Status.Archived      => "Archived"
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/studydesign/ApiStudyDesign.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/studydesign/ApiStudyDesign.scala
index 958ff5d..26c7352 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/studydesign/ApiStudyDesign.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/studydesign/ApiStudyDesign.scala
@@ -11,7 +11,7 @@ object ApiStudyDesign {
   implicit val format: Format[ApiStudyDesign] = (
     (JsPath \ "id").format[Long] and
       (JsPath \ "name").format[String]
-    ) (ApiStudyDesign.apply, unlift(ApiStudyDesign.unapply))
+  )(ApiStudyDesign.apply, unlift(ApiStudyDesign.unapply))
 
   def fromDomain(studyDesign: StudyDesign) = ApiStudyDesign(
     id = studyDesign.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/ApiPartialTrial.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/ApiPartialTrial.scala
index 0dc1446..f89f181 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/ApiPartialTrial.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/ApiPartialTrial.scala
@@ -31,14 +31,14 @@ object ApiPartialTrial {
       (JsPath \ "studyDesignId").readTristate[Long] and
       (JsPath \ "overview").readTristate[String] and
       (JsPath \ "title").readTristate[String]
-    ) (ApiPartialTrial.apply _)
+  )(ApiPartialTrial.apply _)
 
   private val writes: Writes[ApiPartialTrial] = (
     (JsPath \ "hypothesisId").writeTristate[UUID] and
       (JsPath \ "studyDesignId").writeTristate[Long] and
       (JsPath \ "overview").writeTristate[String] and
       (JsPath \ "title").writeTristate[String]
-    ) (unlift(ApiPartialTrial.unapply))
+  )(unlift(ApiPartialTrial.unapply))
 
   implicit val format: Format[ApiPartialTrial] = Format(reads, writes)
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/ApiTrial.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/ApiTrial.scala
index 3267617..db980ee 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/ApiTrial.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/ApiTrial.scala
@@ -41,7 +41,7 @@ object ApiTrial {
       (JsPath \ "overviewTemplate").format[String] and
       (JsPath \ "isUpdated").format[Boolean] and
       (JsPath \ "title").format[String]
-    ) (ApiTrial.apply, unlift(ApiTrial.unapply))
+  )(ApiTrial.apply, unlift(ApiTrial.unapply))
 
   def fromDomain(trial: Trial): ApiTrial = ApiTrial(
     id = trial.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/TrialStatus.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/TrialStatus.scala
index 49bcbcb..a5b557b 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/TrialStatus.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/TrialStatus.scala
@@ -5,26 +5,26 @@ import xyz.driver.pdsuidomain.entities.Trial.Status
 object TrialStatus {
 
   val statusFromString: PartialFunction[String, Status] = {
-    case "New" => Status.New
-    case "ReviewSummary" => Status.ReviewSummary
-    case "Summarized" => Status.Summarized
-    case "PendingUpdate" => Status.PendingUpdate
-    case "Update" => Status.Update
+    case "New"            => Status.New
+    case "ReviewSummary"  => Status.ReviewSummary
+    case "Summarized"     => Status.Summarized
+    case "PendingUpdate"  => Status.PendingUpdate
+    case "Update"         => Status.Update
     case "ReviewCriteria" => Status.ReviewCriteria
-    case "Done" => Status.Done
-    case "Flagged" => Status.Flagged
-    case "Archived" => Status.Archived
+    case "Done"           => Status.Done
+    case "Flagged"        => Status.Flagged
+    case "Archived"       => Status.Archived
   }
 
   def statusToString(x: Status): String = x match {
-    case Status.New => "New"
-    case Status.ReviewSummary => "ReviewSummary"
-    case Status.Summarized => "Summarized"
-    case Status.PendingUpdate => "PendingUpdate"
-    case Status.Update => "Update"
+    case Status.New            => "New"
+    case Status.ReviewSummary  => "ReviewSummary"
+    case Status.Summarized     => "Summarized"
+    case Status.PendingUpdate  => "PendingUpdate"
+    case Status.Update         => "Update"
     case Status.ReviewCriteria => "ReviewCriteria"
-    case Status.Done => "Done"
-    case Status.Flagged => "Flagged"
-    case Status.Archived => "Archived"
+    case Status.Done           => "Done"
+    case Status.Flagged        => "Flagged"
+    case Status.Archived       => "Archived"
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/ApiPartialUser.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/ApiPartialUser.scala
index 977934b..654508c 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/ApiPartialUser.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/ApiPartialUser.scala
@@ -14,9 +14,7 @@ import ApiPartialUser._
 import xyz.driver.pdsuicommon.json.JsonValidationException
 import xyz.driver.pdsuicommon.validation.{AdditionalConstraints, JsonValidationErrors}
 
-final case class ApiPartialUser(email: Option[String],
-                                name: Option[String],
-                                roleId: Option[String]) {
+final case class ApiPartialUser(email: Option[String], name: Option[String], roleId: Option[String]) {
 
   def applyTo(orig: User): Try[User] = Try {
     val validation = Map(
@@ -36,8 +34,8 @@ final case class ApiPartialUser(email: Option[String],
 
   def toDomain(id: LongId[User] = LongId(0L)): Try[User] = Try {
     val validation = Map(
-      JsPath \ "email" -> AdditionalConstraints.optionNonEmptyConstraint(email),
-      JsPath \ "name" -> AdditionalConstraints.optionNonEmptyConstraint(name),
+      JsPath \ "email"  -> AdditionalConstraints.optionNonEmptyConstraint(email),
+      JsPath \ "name"   -> AdditionalConstraints.optionNonEmptyConstraint(name),
       JsPath \ "roleId" -> AdditionalConstraints.optionNonEmptyConstraint(roleId)
     )
 
@@ -71,13 +69,19 @@ object ApiPartialUser {
 
   implicit val format: Format[ApiPartialUser] = (
     (JsPath \ "email").formatNullable[String](Format(Reads.email, Writes.StringWrites)) and
-      (JsPath \ "name").formatNullable[String](Format(
-        Reads.filterNot[String](ValidationError("Username is too long (max length is 255 chars)", 255))(_.length > 255),
-        Writes.StringWrites
-      )) and
-      (JsPath \ "roleId").formatNullable[String](Format(Reads.of[String].filter(ValidationError("unknown role"))({
-        case x if UserRole.roleFromString.isDefinedAt(x) => true
-        case _ => false
-      }), Writes.of[String]))
-    ) (ApiPartialUser.apply, unlift(ApiPartialUser.unapply))
+      (JsPath \ "name").formatNullable[String](
+        Format(
+          Reads.filterNot[String](ValidationError("Username is too long (max length is 255 chars)", 255))(
+            _.length > 255),
+          Writes.StringWrites
+        )) and
+      (JsPath \ "roleId").formatNullable[String](
+        Format(Reads
+                 .of[String]
+                 .filter(ValidationError("unknown role"))({
+                   case x if UserRole.roleFromString.isDefinedAt(x) => true
+                   case _                                           => false
+                 }),
+               Writes.of[String]))
+  )(ApiPartialUser.apply, unlift(ApiPartialUser.unapply))
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/ApiUser.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/ApiUser.scala
index c2653ec..29138ed 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/ApiUser.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/ApiUser.scala
@@ -15,12 +15,16 @@ object ApiUser {
     (JsPath \ "id").format[Long] and
       (JsPath \ "email").format[String](Reads.email) and
       (JsPath \ "name").format[String] and
-      (JsPath \ "roleId").format[String](Format(Reads.of[String].filter(ValidationError("unknown role"))({
-        case x if UserRole.roleFromString.isDefinedAt(x) => true
-        case _ => false
-      }), Writes.of[String])) and
+      (JsPath \ "roleId").format[String](
+        Format(Reads
+                 .of[String]
+                 .filter(ValidationError("unknown role"))({
+                   case x if UserRole.roleFromString.isDefinedAt(x) => true
+                   case _                                           => false
+                 }),
+               Writes.of[String])) and
       (JsPath \ "latestActivity").formatNullable[ZonedDateTime]
-    ) (ApiUser.apply, unlift(ApiUser.unapply))
+  )(ApiUser.apply, unlift(ApiUser.unapply))
 
   def fromDomain(user: User) = ApiUser(
     user.id.id,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/UserRole.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/UserRole.scala
index 74acb81..412a969 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/UserRole.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/UserRole.scala
@@ -5,29 +5,33 @@ import xyz.driver.pdsuicommon.domain.User.Role
 object UserRole {
 
   val roleFromString: PartialFunction[String, Role] = {
-    case "Cleaner" => Role.RecordCleaner
-    case "Organizer" => Role.RecordOrganizer
-    case "Extractor" => Role.DocumentExtractor
-    case "RecordAdmin" => Role.RecordAdmin
-    case "TrialSummarizer" => Role.TrialSummarizer
-    case "CriteriaCurator" => Role.CriteriaCurator
-    case "TrialAdmin" => Role.TrialAdmin
-    case "EligibilityVerifier" => Role.EligibilityVerifier
+    case "Cleaner"                => Role.RecordCleaner
+    case "Organizer"              => Role.RecordOrganizer
+    case "Extractor"              => Role.DocumentExtractor
+    case "RecordAdmin"            => Role.RecordAdmin
+    case "TrialSummarizer"        => Role.TrialSummarizer
+    case "CriteriaCurator"        => Role.CriteriaCurator
+    case "TrialAdmin"             => Role.TrialAdmin
+    case "EligibilityVerifier"    => Role.EligibilityVerifier
     case "TreatmentMatchingAdmin" => Role.TreatmentMatchingAdmin
-    case "RoutesCurator" => Role.RoutesCurator
+    case "RoutesCurator"          => Role.RoutesCurator
+    case "SystemUser"             => Role.SystemUser
+    case "ResearchOncologist"     => Role.ResearchOncologist
     // No Mixed at this time
   }
 
   def roleToString(x: Role): String = x match {
-    case Role.RecordCleaner => "Cleaner"
-    case Role.RecordOrganizer => "Organizer"
-    case Role.DocumentExtractor => "Extractor"
-    case Role.RecordAdmin => "RecordAdmin"
-    case Role.TrialSummarizer => "TrialSummarizer"
-    case Role.CriteriaCurator => "CriteriaCurator"
-    case Role.TrialAdmin => "TrialAdmin"
-    case Role.EligibilityVerifier => "EligibilityVerifier"
+    case Role.RecordCleaner          => "Cleaner"
+    case Role.RecordOrganizer        => "Organizer"
+    case Role.DocumentExtractor      => "Extractor"
+    case Role.RecordAdmin            => "RecordAdmin"
+    case Role.TrialSummarizer        => "TrialSummarizer"
+    case Role.CriteriaCurator        => "CriteriaCurator"
+    case Role.TrialAdmin             => "TrialAdmin"
+    case Role.EligibilityVerifier    => "EligibilityVerifier"
     case Role.TreatmentMatchingAdmin => "TreatmentMatchingAdmin"
-    case Role.RoutesCurator => "RoutesCurator"
+    case Role.RoutesCurator          => "RoutesCurator"
+    case Role.SystemUser             => "SystemUser"
+    case Role.ResearchOncologist     => "ResearchOncologist"
   }
 }