fix merge conflictsv0.7.5

36 files changed, 317 insertions, 232 deletions

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 1869ff3..3f1ecfe 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
@@ -2,7 +2,6 @@ package xyz.driver.pdsuidomain.formats.json.document
 
 import java.time.{LocalDate, ZoneId, ZonedDateTime}
 import xyz.driver.pdsuicommon.domain.{LongId, StringId, TextJson}
-import xyz.driver.pdsuicommon.json.JsonSerializer
 
 import xyz.driver.pdsuidomain.entities._
 import play.api.data.validation.ValidationError
@@ -20,6 +19,7 @@ final case class ApiDocument(id: Long,
                              provider: Option[String],
                              providerTypeId: Option[Long],
                              requiredType: Option[String],
+                             institutionName: Option[String],
                              status: Option[String],
                              previousStatus: Option[String],
                              assignee: Option[String],
@@ -46,6 +46,7 @@ final case class ApiDocument(id: Long,
     providerName = this.provider,
     providerTypeId = this.providerTypeId.map(LongId(_)),
     requiredType = this.requiredType.map(extractRequiredType),
+    institutionName = this.institutionName,
     meta = this.meta.map(x => TextJson(JsonSerializer.deserialize[Document.Meta](x))),
     startDate = this.startDate,
     endDate = this.endDate,
@@ -74,6 +75,7 @@ object ApiDocument {
       (JsPath \ "provider").formatNullable[String] and
       (JsPath \ "providerTypeId").formatNullable[Long] and
       (JsPath \ "requiredType").formatNullable[String] and
+      (JsPath \ "institutionName").formatNullable[String] and
       (JsPath \ "status").formatNullable(statusFormat) and
       (JsPath \ "previousStatus").formatNullable(statusFormat) and
       (JsPath \ "assignee").formatNullable[String] and
@@ -96,6 +98,7 @@ object ApiDocument {
       provider = document.providerName,
       providerTypeId = document.providerTypeId.map(_.id),
       requiredType = document.requiredType.map(Document.RequiredType.requiredTypeToString),
+      institutionName = document.institutionName,
       status = Option(Document.Status.statusToString(document.status)),
       previousStatus = document.previousStatus.map(Document.Status.statusToString),
       assignee = document.assignee.map(_.id),
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiPartialDocument.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiPartialDocument.scala
index eae0c62..032ddf6 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiPartialDocument.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiPartialDocument.scala
@@ -23,6 +23,7 @@ final case class ApiPartialDocument(recordId: Option[Long],
                                     endDate: Tristate[LocalDate],
                                     provider: Tristate[String],
                                     providerTypeId: Tristate[Long],
+                                    institutionName: Tristate[String],
                                     status: Option[String],
                                     assignee: Tristate[String],
                                     meta: Tristate[String]) {
@@ -42,6 +43,7 @@ final case class ApiPartialDocument(recordId: Option[Long],
     providerName = provider.cata(Some(_), None, orig.providerName),
     providerTypeId = providerTypeId.map(LongId[ProviderType]).cata(Some(_), None, orig.providerTypeId),
     requiredType = orig.requiredType,
+    institutionName = institutionName.cata(Some(_), None, orig.institutionName),
     meta = meta.cata(x => Some(TextJson(JsonSerializer.deserialize[Meta](x))), None, orig.meta),
     startDate = startDate.cata(Some(_), None, orig.startDate),
     endDate = endDate.cata(Some(_), None, orig.endDate),
@@ -67,6 +69,7 @@ final case class ApiPartialDocument(recordId: Option[Long],
         providerName = provider.toOption,
         providerTypeId = providerTypeId.map(LongId[ProviderType]).toOption,
         requiredType = None,
+        institutionName = institutionName.toOption,
         meta = meta.map(x => TextJson(JsonSerializer.deserialize[Meta](x))).toOption,
         previousStatus = None,
         assignee = None,
@@ -90,6 +93,7 @@ object ApiPartialDocument {
       (JsPath \ "endDate").readTristate[LocalDate] and
       (JsPath \ "provider").readTristate[String] and
       (JsPath \ "providerTypeId").readTristate[Long] and
+      (JsPath \ "institutionName").readTristate[String] and
       (JsPath \ "status").readNullable[String](
         Reads
           .of[String]
@@ -115,6 +119,7 @@ object ApiPartialDocument {
       (JsPath \ "endDate").writeTristate[LocalDate] and
       (JsPath \ "provider").writeTristate[String] and
       (JsPath \ "providerTypeId").writeTristate[Long] and
+      (JsPath \ "institutionName").writeTristate[String] and
       (JsPath \ "status").writeNullable[String] and
       (JsPath \ "assignee").writeTristate[String] and
       (JsPath \ "meta").writeTristate(Writes[String](Json.parse))
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/eligibilityarm/ApiEligibilityArm.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/eligibilityarm/ApiEligibilityArm.scala
index e7eb022..71423e8 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/eligibilityarm/ApiEligibilityArm.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/eligibilityarm/ApiEligibilityArm.scala
@@ -1,20 +1,36 @@
 package xyz.driver.pdsuidomain.formats.json.eligibilityarm
 
-import xyz.driver.pdsuicommon.domain.{LongId, StringId}
-import xyz.driver.pdsuidomain.entities.EligibilityArm
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
+import xyz.driver.entities.patient.CancerType
+import xyz.driver.pdsuicommon.domain.{LongId, StringId}
+import xyz.driver.pdsuidomain.entities.{EligibilityArm, EligibilityArmDisease, EligibilityArmWithDiseases}
 
-final case class ApiEligibilityArm(id: Long, name: String, originalName: String, trialId: String) {
+final case class ApiEligibilityArm(id: Long,
+                                   name: String,
+                                   originalName: String,
+                                   trialId: String,
+                                   diseases: Seq[String]) {
 
-  def toDomain: EligibilityArm = EligibilityArm(
-    id = LongId(this.id),
-    name = this.name,
-    originalName = this.originalName,
-    trialId = StringId(this.trialId),
-    deleted = None // if we have an ApiEligibilityArm object, the EligibilityArm itself has not been deleted
-  )
+  def toDomain: EligibilityArmWithDiseases = {
+    val eligibilityArm = EligibilityArm(
+      id = LongId(this.id),
+      name = this.name,
+      originalName = this.originalName,
+      trialId = StringId(this.trialId),
+      deleted = None // if we have an ApiEligibilityArm object, the EligibilityArm itself has not been deleted
+    )
 
+    EligibilityArmWithDiseases(
+      eligibilityArm,
+      this.diseases.map { disease =>
+        val condition = CancerType
+          .fromString(disease)
+          .getOrElse(throw new NoSuchElementException(s"unknown condition $disease"))
+        EligibilityArmDisease(eligibilityArm.id, condition)
+      }
+    )
+  }
 }
 
 object ApiEligibilityArm {
@@ -23,13 +39,19 @@ object ApiEligibilityArm {
     (JsPath \ "id").format[Long] and
       (JsPath \ "name").format[String] and
       (JsPath \ "originalName").format[String] and
-      (JsPath \ "trialId").format[String]
+      (JsPath \ "trialId").format[String] and
+      (JsPath \ "diseases").format[Seq[String]]
   )(ApiEligibilityArm.apply, unlift(ApiEligibilityArm.unapply))
 
-  def fromDomain(arm: EligibilityArm): ApiEligibilityArm = ApiEligibilityArm(
-    id = arm.id.id,
-    name = arm.name,
-    originalName = arm.originalName,
-    trialId = arm.trialId.id
-  )
+  def fromDomain(eligibilityArmWithDiseases: EligibilityArmWithDiseases): ApiEligibilityArm = {
+    import eligibilityArmWithDiseases.{eligibilityArm, eligibilityArmDiseases}
+
+    ApiEligibilityArm(
+      id = eligibilityArm.id.id,
+      name = eligibilityArm.name,
+      originalName = eligibilityArm.originalName,
+      trialId = eligibilityArm.trialId.id,
+      diseases = eligibilityArmDiseases.map(_.disease.toString)
+    )
+  }
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/eligibilityarm/ApiEligibilityCreateArm.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/eligibilityarm/ApiEligibilityCreateArm.scala
index 6f55c10..087fed5 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/eligibilityarm/ApiEligibilityCreateArm.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/eligibilityarm/ApiEligibilityCreateArm.scala
@@ -1,17 +1,30 @@
 package xyz.driver.pdsuidomain.formats.json.eligibilityarm
 
-import xyz.driver.pdsuicommon.domain.{LongId, StringId}
-import xyz.driver.pdsuidomain.entities.EligibilityArm
 import play.api.libs.json.{Format, Json}
+import xyz.driver.entities.patient.CancerType
+import xyz.driver.pdsuicommon.domain.{LongId, StringId}
+import xyz.driver.pdsuidomain.entities.{EligibilityArm, EligibilityArmDisease, EligibilityArmWithDiseases}
+
+final case class ApiCreateEligibilityArm(name: String, trialId: String, diseases: Seq[String]) {
 
-final case class ApiCreateEligibilityArm(name: String, trialId: String) {
+  def toDomain: EligibilityArmWithDiseases = {
+    val eligibilityArm = EligibilityArm(
+      id = LongId(0),
+      name = name,
+      trialId = StringId(trialId),
+      originalName = name
+    )
 
-  def toDomain = EligibilityArm(
-    id = LongId(0),
-    name = name,
-    trialId = StringId(trialId),
-    originalName = name
-  )
+    EligibilityArmWithDiseases(
+      eligibilityArm,
+      diseases.map { disease =>
+        val condition = CancerType
+          .fromString(disease)
+          .getOrElse(throw new NoSuchElementException(s"unknown condition $disease"))
+        EligibilityArmDisease(eligibilityArm.id, condition)
+      }
+    )
+  }
 }
 
 object ApiCreateEligibilityArm {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/eligibilityarm/ApiPartialEligibilityArm.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/eligibilityarm/ApiPartialEligibilityArm.scala
index cc3d460..aca22ef 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/eligibilityarm/ApiPartialEligibilityArm.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/eligibilityarm/ApiPartialEligibilityArm.scala
@@ -1,11 +1,20 @@
 package xyz.driver.pdsuidomain.formats.json.eligibilityarm
 
-import xyz.driver.pdsuidomain.entities.EligibilityArm
 import play.api.libs.json.{Format, Json}
+import xyz.driver.entities.patient.CancerType
+import xyz.driver.pdsuidomain.entities.{EligibilityArmDisease, EligibilityArmWithDiseases}
 
-final case class ApiPartialEligibilityArm(name: String) {
+final case class ApiPartialEligibilityArm(name: String, diseases: Seq[String]) {
 
-  def applyTo(arm: EligibilityArm): EligibilityArm = arm.copy(name = name)
+  def applyTo(armWithDisease: EligibilityArmWithDiseases): EligibilityArmWithDiseases = {
+    val arm = armWithDisease.eligibilityArm.copy(name = name)
+    val armDiseases = diseases.map { disease =>
+      EligibilityArmDisease(
+        armWithDisease.eligibilityArm.id,
+        CancerType.fromString(disease).getOrElse(throw new NoSuchElementException(s"unknown condition $disease")))
+    }
+    EligibilityArmWithDiseases(arm, armDiseases)
+  }
 }
 
 object ApiPartialEligibilityArm {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/evidence/ApiPatientLabelEvidence.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/evidence/ApiPatientLabelEvidence.scala
index e0f23e3..c7a6de9 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/evidence/ApiPatientLabelEvidence.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/evidence/ApiPatientLabelEvidence.scala
@@ -3,7 +3,6 @@ package xyz.driver.pdsuidomain.formats.json.evidence
 import java.time.LocalDate
 
 import play.api.libs.json._
-import xyz.driver.pdsuicommon.domain.FuzzyValue
 import xyz.driver.pdsuidomain.entities.PatientLabelEvidenceView
 
 final case class ApiPatientLabelEvidence(id: Long,
@@ -22,13 +21,13 @@ object ApiPatientLabelEvidence {
 
   def fromDomain(x: PatientLabelEvidenceView) = ApiPatientLabelEvidence(
     id = x.id.id,
-    value = FuzzyValue.valueToString(x.value),
+    value = x.value.toString,
     evidenceText = x.evidenceText,
     documentId = x.documentId.map(_.id),
     evidenceId = x.evidenceId.map(_.id),
     reportId = x.reportId.map(_.toString),
-    documentType = x.documentType,
+    documentType = x.documentType.name,
     date = x.date.get,
-    providerType = x.providerType
+    providerType = x.providerType.name
   )
 }
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 d486749..edb0603 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
@@ -1,11 +1,11 @@
 package xyz.driver.pdsuidomain.formats.json.label
 
-import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId}
+import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuidomain.entities.{Criterion, CriterionLabel}
 import play.api.data.validation.ValidationError
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
-import xyz.driver.entities.labels.{Label, LabelCategory}
+import xyz.driver.entities.labels.{Label, LabelCategory, LabelValue}
 
 /**
   * @param value Yes|No
@@ -34,7 +34,7 @@ object ApiCriterionLabel {
     labelId = x.labelId.map(_.id),
     categoryId = x.categoryId.map(_.id),
     value = x.value.map { x =>
-      FuzzyValue.valueToString(FuzzyValue.fromBoolean(x))
+      LabelValue.fromBoolean(x).toString
     },
     isDefining = x.isDefining
   )
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 f8161af..1497679 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
@@ -1,11 +1,11 @@
 package xyz.driver.pdsuidomain.formats.json.label
 
-import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId}
+import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuidomain.entities.{ExtractedData, ExtractedDataLabel}
 import play.api.data.validation.ValidationError
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
-import xyz.driver.entities.labels.{Label, LabelCategory}
+import xyz.driver.entities.labels.{Label, LabelCategory, LabelValue}
 
 final case class ApiExtractedDataLabel(id: Option[Long], categoryId: Option[Long], value: Option[String]) {
 
@@ -14,7 +14,7 @@ final case class ApiExtractedDataLabel(id: Option[Long], categoryId: Option[Long
     dataId = dataId,
     labelId = id.map(LongId[Label]),
     categoryId = categoryId.map(LongId[LabelCategory]),
-    value = value.map(FuzzyValue.fromString)
+    value = value.flatMap(LabelValue.fromString)
   )
 }
 
@@ -27,8 +27,8 @@ object ApiExtractedDataLabel {
         Format(Reads
                  .of[String]
                  .filter(ValidationError("unknown value"))({
-                   case x if FuzzyValue.fromString.isDefinedAt(x) => true
-                   case _                                         => false
+                   case x if LabelValue.fromString(x).isDefined => true
+                   case _                                       => false
                  }),
                Writes.of[String]))
   )(ApiExtractedDataLabel.apply, unlift(ApiExtractedDataLabel.unapply))
@@ -36,6 +36,6 @@ object ApiExtractedDataLabel {
   def fromDomain(dataLabel: ExtractedDataLabel) = ApiExtractedDataLabel(
     id = dataLabel.labelId.map(_.id),
     categoryId = dataLabel.categoryId.map(_.id),
-    value = dataLabel.value.map(FuzzyValue.valueToString)
+    value = dataLabel.value.map(_.toString)
   )
 }
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 db430ae..585d4ed 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
@@ -7,6 +7,8 @@ import xyz.driver.pdsuicommon.domain.{StringId, UuidId}
 import xyz.driver.pdsuidomain.entities.{Patient, PatientOrderId}
 import play.api.libs.functional.syntax._
 import play.api.libs.json.{Format, JsPath}
+import xyz.driver.entities.common.FullName
+import xyz.driver.entities.patient
 
 final case class ApiPatient(id: String,
                             status: String,
@@ -17,24 +19,35 @@ final case class ApiPatient(id: String,
                             previousAssignee: Option[String],
                             lastActiveUser: Option[String],
                             lastUpdate: ZonedDateTime,
-                            condition: String,
+                            disease: String,
                             orderId: UUID) {
 
   private def extractStatus(status: String): Patient.Status =
     PatientStatus.statusFromString
       .applyOrElse(status, (s: String) => throw new NoSuchElementException(s"Unknown status $s"))
 
+  private def parseName(name: String): FullName[Patient] =
+    name.split(" ") match {
+      case Array()                    => throw new NoSuchElementException(s"Patient's name cannot be empty")
+      case Array(first)               => FullName.fromStrings[Patient](first, "", "")
+      case Array(first, last)         => FullName.fromStrings[Patient](first, "", last)
+      case Array(first, middle, last) => FullName.fromStrings[Patient](first, middle, last)
+      case _                          => throw new NoSuchElementException(s"Patient's name is ambiguous")
+    }
+
   def toDomain = Patient(
     id = UuidId(this.id),
     status = extractStatus(this.status),
-    name = this.name,
+    name = parseName(this.name),
     dob = this.dob,
     assignee = this.assignee.map(StringId(_)),
     previousStatus = this.previousStatus.map(extractStatus),
     previousAssignee = this.previousAssignee.map(StringId(_)),
     lastActiveUserId = this.lastActiveUser.map(StringId(_)),
     isUpdateRequired = false,
-    condition = this.condition,
+    disease = patient.CancerType
+      .fromString(this.disease)
+      .getOrElse(throw new IllegalArgumentException(s"Unknown cancer type ${this.disease}")),
     orderId = PatientOrderId(this.orderId),
     lastUpdate = this.lastUpdate.toLocalDateTime
   )
@@ -53,21 +66,21 @@ object ApiPatient {
       (JsPath \ "previousAssignee").formatNullable[String] and
       (JsPath \ "lastActiveUser").formatNullable[String] and
       (JsPath \ "lastUpdate").format[ZonedDateTime] and
-      (JsPath \ "condition").format[String] and
+      (JsPath \ "disease").format[String] and
       (JsPath \ "orderId").format[UUID]
   )(ApiPatient.apply, unlift(ApiPatient.unapply))
 
   def fromDomain(patient: Patient) = ApiPatient(
     id = patient.id.toString,
     status = PatientStatus.statusToString(patient.status),
-    name = patient.name,
+    name = patient.name.toString(),
     dob = patient.dob,
     assignee = patient.assignee.map(_.id),
     previousStatus = patient.previousStatus.map(PatientStatus.statusToString),
     previousAssignee = patient.previousAssignee.map(_.id),
     lastActiveUser = patient.lastActiveUserId.map(_.id),
     lastUpdate = ZonedDateTime.of(patient.lastUpdate, ZoneId.of("Z")),
-    condition = patient.condition,
+    disease = patient.disease.toString,
     orderId = patient.orderId.id
   )
 }
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 4136715..55c8149 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
@@ -5,7 +5,7 @@ import java.util.UUID
 import play.api.data.validation.ValidationError
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
-import xyz.driver.pdsuicommon.domain.FuzzyValue
+import xyz.driver.entities.labels.LabelValue
 import xyz.driver.pdsuidomain.services.PatientEligibleTrialService.RichPatientEligibleTrial
 
 final case class ApiPatientEligibleTrial(id: Long,
@@ -30,8 +30,8 @@ object ApiPatientEligibleTrial {
         Reads
           .of[String]
           .filter(ValidationError("unknown eligibility status"))({
-            case x if FuzzyValue.fromString.isDefinedAt(x) => true
-            case _                                         => false
+            case x if LabelValue.fromString(x).isDefined => true
+            case _                                       => false
           }),
         Writes.of[String]
       )) and
@@ -45,7 +45,7 @@ object ApiPatientEligibleTrial {
     trialTitle = eligibleTrialWithTrial.trial.title,
     arms = eligibleTrialWithTrial.arms.map(_.armName),
     hypothesisId = eligibleTrialWithTrial.group.hypothesisId.id,
-    eligibleTrialWithTrial.group.verifiedEligibilityStatus.map(FuzzyValue.valueToString),
+    eligibleTrialWithTrial.group.verifiedEligibilityStatus.map(_.toString),
     eligibleTrialWithTrial.group.isVerified
   )
 }
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 91d0a0e..d92872c 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
@@ -6,15 +6,14 @@ import org.davidbild.tristate.contrib.play.ToJsPathOpsFromJsPath
 import play.api.data.validation.ValidationError
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
-import xyz.driver.pdsuicommon.domain.FuzzyValue
+import xyz.driver.entities.labels.LabelValue
 
 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)
+      primaryValue = primaryValue.flatMap(LabelValue.fromString).orElse(orig.primaryValue),
+      verifiedPrimaryValue = verifiedPrimaryValue.cata(x => LabelValue.fromString(x), None, orig.verifiedPrimaryValue)
     )
   }
 }
@@ -26,8 +25,8 @@ object ApiPartialPatientLabel {
       Format(Reads
                .of[String]
                .filter(ValidationError("unknown primary value"))({
-                 case x if FuzzyValue.fromString.isDefinedAt(x) => true
-                 case _                                         => false
+                 case x if LabelValue.fromString(x).isDefined => true
+                 case _                                       => false
                }),
              Writes.of[String])) and
       (JsPath \ "verifiedPrimaryValue").formatTristate[String](
@@ -35,8 +34,8 @@ object ApiPartialPatientLabel {
           Reads
             .of[String]
             .filter(ValidationError("unknown verified primary value"))({
-              case x if FuzzyValue.fromString.isDefinedAt(x) => true
-              case _                                         => false
+              case x if LabelValue.fromString(x).isDefined => true
+              case _                                       => false
             }),
           Writes.of[String]
         ))
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPatientLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPatientLabel.scala
index fc8687b..cc8532d 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPatientLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPatientLabel.scala
@@ -4,7 +4,7 @@ import xyz.driver.pdsuidomain.entities.PatientLabel
 import play.api.data.validation.ValidationError
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
-import xyz.driver.pdsuicommon.domain.FuzzyValue
+import xyz.driver.entities.labels.LabelValue
 
 final case class ApiPatientLabel(id: Long,
                                  labelId: Long,
@@ -20,25 +20,33 @@ object ApiPatientLabel {
   implicit val apiPatientLabelJsonFormat: Format[ApiPatientLabel] = (
     (JsPath \ "id").format[Long] and
       (JsPath \ "labelId").format[Long] and
-      (JsPath \ "primaryValue").formatNullable[String](Format(Reads.of[String].filter(ValidationError("unknown value"))({
-        case x if FuzzyValue.fromString.isDefinedAt(x) => true
-        case _ => false
-      }), Writes.of[String])) and
-      (JsPath \ "verifiedPrimaryValue").formatNullable[String](Format(Reads.of[String].filter(ValidationError("unknown value"))({
-        case x if FuzzyValue.fromString.isDefinedAt(x) => true
-        case _ => false
-      }), Writes.of[String])) and
+      (JsPath \ "primaryValue").formatNullable[String](
+        Format(Reads
+                 .of[String]
+                 .filter(ValidationError("unknown value"))({
+                   case x if LabelValue.fromString(x).isDefined => true
+                   case _                                       => false
+                 }),
+               Writes.of[String])) and
+      (JsPath \ "verifiedPrimaryValue").formatNullable[String](
+        Format(Reads
+                 .of[String]
+                 .filter(ValidationError("unknown value"))({
+                   case x if LabelValue.fromString(x).isDefined => true
+                   case _                                       => false
+                 }),
+               Writes.of[String])) and
       (JsPath \ "score").format[Int] and
       (JsPath \ "isImplicitMatch").format[Boolean] and
       (JsPath \ "isVisible").format[Boolean] and
       (JsPath \ "isVerified").format[Boolean]
-    ) (ApiPatientLabel.apply, unlift(ApiPatientLabel.unapply))
+  )(ApiPatientLabel.apply, unlift(ApiPatientLabel.unapply))
 
   def fromDomain(patientLabel: PatientLabel, isVerified: Boolean): ApiPatientLabel = ApiPatientLabel(
     id = patientLabel.id.id,
     labelId = patientLabel.labelId.id,
-    primaryValue = patientLabel.primaryValue.map(FuzzyValue.valueToString),
-    verifiedPrimaryValue = patientLabel.verifiedPrimaryValue.map(FuzzyValue.valueToString),
+    primaryValue = patientLabel.primaryValue.map(_.toString),
+    verifiedPrimaryValue = patientLabel.verifiedPrimaryValue.map(_.toString),
     score = patientLabel.score,
     isImplicitMatch = patientLabel.isImplicitMatch,
     isVisible = patientLabel.isVisible,
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 ae64c33..16b9cc9 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
@@ -3,7 +3,7 @@ package xyz.driver.pdsuidomain.formats.json.patient.label
 import play.api.data.validation.ValidationError
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
-import xyz.driver.pdsuicommon.domain.FuzzyValue
+import xyz.driver.entities.labels.LabelValue
 import xyz.driver.pdsuidomain.entities.PatientLabel
 
 final case class ApiPatientLabelDefiningCriteria(labelId: Long, value: Option[String])
@@ -16,14 +16,14 @@ object ApiPatientLabelDefiningCriteria {
         Format(Reads
                  .of[String]
                  .filter(ValidationError("unknown value"))({
-                   case x if FuzzyValue.fromString.isDefinedAt(x) => true
-                   case _                                         => false
+                   case x if LabelValue.fromString(x).isDefined => true
+                   case _                                       => false
                  }),
                Writes.of[String]))
   )(ApiPatientLabelDefiningCriteria.apply, unlift(ApiPatientLabelDefiningCriteria.unapply))
 
   def fromDomain(x: PatientLabel) = ApiPatientLabelDefiningCriteria(
     labelId = x.labelId.id,
-    value = x.verifiedPrimaryValue.map(FuzzyValue.valueToString)
+    value = x.verifiedPrimaryValue.map(_.toString)
   )
 }
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 399bc7d..09538b8 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
@@ -6,16 +6,16 @@ import org.davidbild.tristate.contrib.play.ToJsPathOpsFromJsPath
 import play.api.data.validation.ValidationError
 import play.api.libs.functional.syntax._
 import play.api.libs.json.{Format, JsPath, Reads, Writes}
-import xyz.driver.pdsuicommon.domain.FuzzyValue
+import xyz.driver.entities.labels.LabelValue
 
 final case class ApiPartialPatientCriterion(eligibilityStatus: Option[String],
                                             verifiedEligibilityStatus: Tristate[String]) {
 
   def applyTo(orig: PatientCriterion): PatientCriterion = {
     orig.copy(
-      eligibilityStatus = eligibilityStatus.map(FuzzyValue.fromString).orElse(orig.eligibilityStatus),
+      eligibilityStatus = eligibilityStatus.flatMap(LabelValue.fromString).orElse(orig.eligibilityStatus),
       verifiedEligibilityStatus =
-        verifiedEligibilityStatus.cata(x => Some(FuzzyValue.fromString(x)), None, orig.verifiedEligibilityStatus)
+        verifiedEligibilityStatus.cata(x => LabelValue.fromString(x), None, orig.verifiedEligibilityStatus)
     )
   }
 }
@@ -28,8 +28,8 @@ object ApiPartialPatientCriterion {
         Reads
           .of[String]
           .filter(ValidationError("unknown eligibility status"))({
-            case x if FuzzyValue.fromString.isDefinedAt(x) => true
-            case _                                         => false
+            case x if LabelValue.fromString(x).isDefined => true
+            case _                                       => false
           }),
         Writes.of[String]
       )) and
@@ -38,8 +38,8 @@ object ApiPartialPatientCriterion {
           Reads
             .of[String]
             .filter(ValidationError("unknown verified eligibility status"))({
-              case x if FuzzyValue.fromString.isDefinedAt(x) => true
-              case _                                         => false
+              case x if LabelValue.fromString(x).isDefined => true
+              case _                                       => false
             }),
           Writes.of[String]
         ))
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 4b08970..b7616a1 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
@@ -1,10 +1,11 @@
 package xyz.driver.pdsuidomain.formats.json.patient.trial
 
-import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId}
+import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuidomain.entities.PatientCriterion
 import play.api.data.validation.ValidationError
 import play.api.libs.functional.syntax._
 import play.api.libs.json.{Format, JsPath, Reads, Writes}
+import xyz.driver.entities.labels.LabelValue
 import xyz.driver.pdsuidomain.services.PatientCriterionService.DraftPatientCriterion
 
 final case class ApiPartialPatientCriterionList(id: Long,
@@ -13,7 +14,7 @@ final case class ApiPartialPatientCriterionList(id: Long,
 
   def toDomain: DraftPatientCriterion = DraftPatientCriterion(
     id = LongId[PatientCriterion](id),
-    eligibilityStatus = eligibilityStatus.map(FuzzyValue.fromString),
+    eligibilityStatus = eligibilityStatus.flatMap(LabelValue.fromString),
     isVerified = isVerified
   )
 }
@@ -26,8 +27,8 @@ object ApiPartialPatientCriterionList {
         Reads
           .of[String]
           .filter(ValidationError("unknown eligibility status"))({
-            case x if FuzzyValue.fromString.isDefinedAt(x) => true
-            case _                                         => false
+            case x if LabelValue.fromString(x).isDefined => true
+            case _                                       => false
           }),
         Writes.of[String]
       )) and
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPatientCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPatientCriterion.scala
index 6eeb40b..b9bf772 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPatientCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPatientCriterion.scala
@@ -2,12 +2,12 @@ package xyz.driver.pdsuidomain.formats.json.patient.trial
 
 import java.time.{ZoneId, ZonedDateTime}
 
-import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId}
+import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuidomain.entities.{PatientCriterion, PatientCriterionArm}
 import play.api.data.validation.ValidationError
 import play.api.libs.functional.syntax._
 import play.api.libs.json.{Format, JsPath, Reads, Writes}
-import xyz.driver.entities.labels.Label
+import xyz.driver.entities.labels.{Label, LabelValue}
 
 final case class ApiPatientCriterion(id: Long,
                                      labelId: Long,
@@ -39,13 +39,13 @@ object ApiPatientCriterion {
       (JsPath \ "criterionIsCompound").format[Boolean] and
       (JsPath \ "arms").format[List[String]] and
       (JsPath \ "eligibilityStatus").formatNullable[String](Format(Reads.of[String].filter(ValidationError("unknown status"))({
-        case x if FuzzyValue.fromString.isDefinedAt(x) => true
-        case _ => false
+        case x if LabelValue.fromString(x).isDefined => true
+        case _                                       => false
       }), Writes.of[String])) and
       (JsPath \ "verifiedEligibilityStatus").formatNullable[String](Format(
         Reads.of[String].filter(ValidationError("unknown status"))({
-          case x if FuzzyValue.fromString.isDefinedAt(x) => true
-          case _ => false
+          case x if LabelValue.fromString(x).isDefined => true
+          case _                                       => false
         }), Writes.of[String])) and
       (JsPath \ "isVerified").format[Boolean] and
       (JsPath \ "isVisible").format[Boolean] and
@@ -61,13 +61,13 @@ object ApiPatientCriterion {
     criterionId = patientCriterion.criterionId.id,
     criterionText = patientCriterion.criterionText,
     criterionValue = patientCriterion.criterionValue.map { x =>
-      FuzzyValue.valueToString(FuzzyValue.fromBoolean(x))
+      LabelValue.fromBoolean(x).toString
     },
     criterionIsDefining = patientCriterion.criterionIsDefining,
     criterionIsCompound = patientCriterion.criterionValue.isEmpty,
     arms = arms.map(_.armName),
-    eligibilityStatus = patientCriterion.eligibilityStatus.map(FuzzyValue.valueToString),
-    verifiedEligibilityStatus = patientCriterion.verifiedEligibilityStatus.map(FuzzyValue.valueToString),
+    eligibilityStatus = patientCriterion.eligibilityStatus.map(_.toString),
+    verifiedEligibilityStatus = patientCriterion.verifiedEligibilityStatus.map(_.toString),
     isVerified = patientCriterion.isVerified,
     isVisible = patientCriterion.isVisible,
     lastUpdate = ZonedDateTime.of(patientCriterion.lastUpdate, ZoneId.of("Z"))
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 2e5943e..1f8c683 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
@@ -22,8 +22,6 @@ final case class ApiCreateRecord(disease: String, patientId: String, requestId:
     caseId = None,
     physician = None,
     meta = None,
-    predictedMeta = None,
-    predictedDocuments = None,
     lastUpdate = LocalDateTime.now()
   )
 }
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 e7b58cd..fc0a2e7 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
@@ -101,8 +101,6 @@ final case class ApiRecord(id: Long,
         Some(TextJson(JsonSerializer.deserialize[List[MedicalRecord.Meta]](this.meta)))
       }
     },
-    predictedMeta = None,
-    predictedDocuments = None,
     lastUpdate = this.lastUpdate.toLocalDateTime()
   )
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ListResponse.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ListResponse.scala
new file mode 100644
index 0000000..2a670c4
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ListResponse.scala
@@ -0,0 +1,39 @@
+package xyz.driver.pdsuidomain.formats.json.sprayformats
+
+import java.time.LocalDateTime
+
+import spray.json.{RootJsonFormat, _}
+import xyz.driver.pdsuicommon.db.Pagination
+import xyz.driver.pdsuidomain.formats.json.sprayformats.common._
+
+final case class ListResponse[+T](items: Seq[T], meta: ListResponse.Meta)
+
+object ListResponse extends DefaultJsonProtocol {
+  private val itemsField = "items"
+  private val metaField  = "meta"
+
+  final case class Meta(itemsCount: Int, pageNumber: Int, pageSize: Int, lastUpdate: Option[LocalDateTime])
+
+  object Meta {
+    def apply(itemsCount: Int, pagination: Pagination, lastUpdate: Option[LocalDateTime]): Meta = {
+      Meta(
+        itemsCount,
+        pagination.pageNumber,
+        pagination.pageSize,
+        lastUpdate
+      )
+    }
+  }
+
+  implicit val listResponseMetaFormat: RootJsonFormat[Meta] = jsonFormat4(Meta.apply)
+
+  implicit def listResponseMetaWriter[T: JsonWriter]: RootJsonWriter[ListResponse[T]] =
+    new RootJsonWriter[ListResponse[T]] {
+      override def write(listResponse: ListResponse[T]): JsValue = {
+        JsObject(
+          itemsField -> listResponse.items.map(_.toJson).toJson,
+          metaField  -> listResponse.meta.toJson
+        )
+      }
+    }
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/common.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/common.scala
index dbd0a43..61e0e7f 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/common.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/common.scala
@@ -3,7 +3,7 @@ package xyz.driver.pdsuidomain.formats.json.sprayformats
 import java.time.{LocalDate, LocalDateTime, ZoneId, ZonedDateTime}
 
 import spray.json._
-import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, StringId, UuidId}
+import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId}
 
 object common {
 
@@ -55,14 +55,6 @@ object common {
     }
   }
 
-  implicit def fuzzyValueFormat: RootJsonFormat[FuzzyValue] = new RootJsonFormat[FuzzyValue] {
-    override def write(value: FuzzyValue): JsString = JsString(FuzzyValue.valueToString(value))
-    override def read(json: JsValue): FuzzyValue = json match {
-      case JsString(value) => FuzzyValue.fromString(value)
-      case _               => deserializationError(s"Expected value as FuzzyValue, but got $json")
-    }
-  }
-
   implicit val integerFormat: RootJsonFormat[Integer] = new RootJsonFormat[Integer] {
     override def write(obj: Integer): JsNumber = JsNumber(obj.intValue())
     override def read(json: JsValue): Integer = json match {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/criterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/criterion.scala
index 7526d9c..a43e92a 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/criterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/criterion.scala
@@ -10,7 +10,7 @@ object criterion {
   import DefaultJsonProtocol._
   import common._
 
-  implicit val criterionLabelWriter = new JsonWriter[CriterionLabel] {
+  implicit val criterionLabelWriter = new RootJsonWriter[CriterionLabel] {
     override def write(obj: CriterionLabel) = JsObject(
       "labelId"    -> obj.labelId.toJson,
       "categoryId" -> obj.categoryId.toJson,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/document.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/document.scala
index e3f6a9c..69e8b75 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/document.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/document.scala
@@ -26,7 +26,7 @@ object document {
     "PN"  -> RequiredType.PN
   )
 
-  implicit val documentMetaFormat: RootJsonFormat[Meta] = jsonFormat3(Meta.apply)
+  implicit val documentMetaFormat: RootJsonFormat[Meta] = jsonFormat2(Meta.apply)
 
   implicit val documentTypeFormat: RootJsonFormat[DocumentType] = new RootJsonFormat[DocumentType] {
     override def read(json: JsValue): DocumentType = json match {
@@ -40,7 +40,7 @@ object document {
           .fromString(name)
           .getOrElse(deserializationError(s"Unknown document type: $name"))
 
-      case _ => deserializationError(s"Expected Json Object as Intervention type, but got $json")
+      case _ => deserializationError(s"Expected Json Object as Document type, but got $json")
     }
 
     override def write(obj: DocumentType) =
@@ -73,6 +73,11 @@ object document {
         .map(_.convertTo[Option[LongId[ProviderType]]])
         .getOrElse(orig.providerTypeId)
 
+      val institutionName = fields
+        .get("institutionName")
+        .map(_.convertTo[Option[String]])
+        .getOrElse(orig.institutionName)
+
       val meta = fields
         .get("meta")
         .map(_.convertTo[Option[TextJson[Meta]]])
@@ -93,6 +98,7 @@ object document {
         typeId = typeId,
         providerName = provider,
         providerTypeId = providerTypeId,
+        institutionName = institutionName,
         meta = meta,
         startDate = startDate,
         endDate = endDate
@@ -111,6 +117,7 @@ object document {
         "provider"         -> document.providerName.toJson,
         "providerTypeId"   -> document.providerTypeId.toJson,
         "requiredType"     -> document.requiredType.toJson,
+        "institutionName"  -> document.institutionName.toJson,
         "startDate"        -> document.startDate.toJson,
         "endDate"          -> document.endDate.toJson,
         "status"           -> document.status.toJson,
@@ -145,6 +152,10 @@ object document {
           .get("providerTypeId")
           .map(_.convertTo[LongId[ProviderType]])
 
+        val institutionName = fields
+          .get("institutionName")
+          .map(_.convertTo[String])
+
         val meta = fields
           .get("meta")
           .map(_.convertTo[TextJson[Meta]])
@@ -168,6 +179,7 @@ object document {
           providerName = provider,
           providerTypeId = providerTypeId,
           requiredType = None,
+          institutionName = institutionName,
           meta = meta,
           previousStatus = None,
           assignee = None,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/eligibility.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/eligibility.scala
index b836e1c..3c2465f 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/eligibility.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/eligibility.scala
@@ -21,7 +21,7 @@ object eligibility {
   implicit val clinicalDocumentFormat: RootJsonFormat[ClinicalEvidenceDocument] = jsonFormat7(ClinicalEvidenceDocument)
 
   implicit val evidenceDocumentFormat: RootJsonFormat[EvidenceDocument] =
-    GadtJsonFormat.create[EvidenceDocument]("documentType") {
+    GadtJsonFormat.create[EvidenceDocument]("evidenceDocumentType") {
       case _: MolecularEvidenceDocument => "Molecular"
       case _: ClinicalEvidenceDocument  => "Clinical"
     } {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/export.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/export.scala
index 39d5c59..1c4b6b4 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/export.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/export.scala
@@ -2,15 +2,16 @@ package xyz.driver.pdsuidomain.formats.json.sprayformats
 
 import spray.json._
 import xyz.driver.entities.labels.Label
-import xyz.driver.pdsuidomain.entities.{Arm, Criterion}
+import xyz.driver.formats.json.labels._
 import xyz.driver.pdsuidomain.entities.export.patient._
 import xyz.driver.pdsuidomain.entities.export.trial.{ExportTrialArm, ExportTrialLabelCriterion, ExportTrialWithLabels}
+import xyz.driver.pdsuidomain.entities.{Criterion, EligibilityArm}
 
 object export {
   import DefaultJsonProtocol._
   import common._
-  import record._
   import document._
+  import record._
 
   implicit val patientLabelEvidenceDocumentFormat: RootJsonFormat[ExportPatientLabelEvidenceDocument] =
     jsonFormat5(ExportPatientLabelEvidenceDocument.apply)
@@ -67,7 +68,7 @@ object export {
               longIdFormat[Criterion].read(criterionId),
               value,
               longIdFormat[Label].read(labelId),
-              armIdsVector.map(longIdFormat[Arm].read).toSet,
+              armIdsVector.map(longIdFormat[EligibilityArm].read).toSet,
               criterionText,
               isCompound,
               isDefining
@@ -81,12 +82,5 @@ object export {
     }
 
   implicit val trialWithLabelsFormat: RootJsonFormat[ExportTrialWithLabels] =
-    jsonFormat(ExportTrialWithLabels.apply,
-               "nctId",
-               "trialId",
-               "disease",
-               "lastReviewed",
-               "labelVersion",
-               "arms",
-               "criteria")
+    jsonFormat(ExportTrialWithLabels.apply, "nctId", "trialId", "lastReviewed", "labelVersion", "arms", "criteria")
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/extracteddata.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/extracteddata.scala
index d6eadbd..5d5585a 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/extracteddata.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/extracteddata.scala
@@ -1,10 +1,11 @@
 package xyz.driver.pdsuidomain.formats.json.sprayformats
 
 import spray.json._
-import xyz.driver.entities.labels.{Label, LabelCategory}
-import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, TextJson}
+import xyz.driver.entities.labels.{Label, LabelCategory, LabelValue}
+import xyz.driver.pdsuicommon.domain.{LongId, TextJson}
 import xyz.driver.pdsuidomain.entities._
 import xyz.driver.pdsuidomain.services.ExtractedDataService.RichExtractedData
+import xyz.driver.formats.json.labels._
 
 object extracteddata {
   import DefaultJsonProtocol._
@@ -44,7 +45,7 @@ object extracteddata {
 
       val value = fields
         .get("value")
-        .map(_.convertTo[FuzzyValue])
+        .map(_.convertTo[LabelValue])
 
       ExtractedDataLabel(
         id = LongId(0),
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patient.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patient.scala
index 724c391..2b0dfe5 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patient.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patient.scala
@@ -3,6 +3,8 @@ package xyz.driver.pdsuidomain.formats.json.sprayformats
 import spray.json._
 import xyz.driver.core.json.EnumJsonFormat
 import xyz.driver.pdsuidomain.entities._
+import xyz.driver.formats.json.common._
+import xyz.driver.formats.json.patient._
 
 object patient {
   import DefaultJsonProtocol._
@@ -26,7 +28,7 @@ object patient {
     }
   }
 
-  implicit val patientWriter: JsonWriter[Patient] = new JsonWriter[Patient] {
+  implicit val patientWriter: RootJsonWriter[Patient] = new RootJsonWriter[Patient] {
     override def write(patient: Patient): JsValue =
       JsObject(
         "id"               -> patient.id.toJson,
@@ -38,7 +40,7 @@ object patient {
         "previousAssignee" -> patient.previousAssignee.toJson,
         "lastActiveUser"   -> patient.lastActiveUserId.toJson,
         "lastUpdate"       -> patient.lastUpdate.toJson,
-        "condition"        -> patient.condition.toJson,
+        "disease"          -> patient.disease.toJson,
         "orderId"          -> patient.orderId.toJson
       )
   }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientcriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientcriterion.scala
index b091746..7e8c220 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientcriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientcriterion.scala
@@ -1,10 +1,10 @@
 package xyz.driver.pdsuidomain.formats.json.sprayformats
 
 import spray.json._
-import xyz.driver.entities.labels.Label
-import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId}
+import xyz.driver.entities.labels.LabelValue
 import xyz.driver.pdsuidomain.entities._
-import xyz.driver.pdsuidomain.services.PatientCriterionService.DraftPatientCriterion
+import xyz.driver.pdsuidomain.services.PatientCriterionService.{DraftPatientCriterion, RichPatientCriterion}
+import xyz.driver.formats.json.labels._
 
 object patientcriterion {
   import DefaultJsonProtocol._
@@ -15,13 +15,13 @@ object patientcriterion {
       val eligibilityStatus = if (fields.contains("eligibilityStatus")) {
         fields
           .get("eligibilityStatus")
-          .map(_.convertTo[FuzzyValue])
+          .map(_.convertTo[LabelValue])
       } else orig.eligibilityStatus
 
       val verifiedEligibilityStatus = if (fields.contains("verifiedEligibilityStatus")) {
         fields
           .get("verifiedEligibilityStatus")
-          .map(_.convertTo[FuzzyValue])
+          .map(_.convertTo[LabelValue])
       } else orig.verifiedEligibilityStatus
 
       orig.copy(
@@ -38,30 +38,27 @@ object patientcriterion {
     override def read(json: JsValue) = json.convertTo[List[JsValue]].map(_.convertTo[DraftPatientCriterion])
   }
 
-  implicit val patientCriterionWriter: JsonWriter[(PatientCriterion, LongId[Label], List[PatientCriterionArm])] =
-    new JsonWriter[(PatientCriterion, LongId[Label], List[PatientCriterionArm])] {
-      override def write(obj: (PatientCriterion, LongId[Label], List[PatientCriterionArm])): JsValue = {
-        val criterion = obj._1
-        val labelId   = obj._2
-        val arms      = obj._3
+  implicit val patientCriterionWriter: RootJsonWriter[RichPatientCriterion] =
+    new RootJsonWriter[RichPatientCriterion] {
+      override def write(obj: RichPatientCriterion): JsValue = {
         JsObject(
-          "id"            -> criterion.id.toJson,
-          "labelId"       -> labelId.toJson,
-          "nctId"         -> criterion.nctId.toJson,
-          "criterionId"   -> criterion.criterionId.toJson,
-          "criterionText" -> criterion.criterionText.toJson,
-          "criterionValue" -> criterion.criterionValue.map {
+          "id"            -> obj.patientCriterion.id.toJson,
+          "labelId"       -> obj.labelId.toJson,
+          "nctId"         -> obj.patientCriterion.nctId.toJson,
+          "criterionId"   -> obj.patientCriterion.criterionId.toJson,
+          "criterionText" -> obj.patientCriterion.criterionText.toJson,
+          "criterionValue" -> obj.patientCriterion.criterionValue.map {
             case true  => "Yes"
             case false => "No"
           }.toJson,
-          "criterionIsDefining"       -> criterion.criterionIsDefining.toJson,
-          "criterionIsCompound"       -> criterion.criterionValue.isEmpty.toJson,
-          "arms"                      -> arms.map(_.armName).toJson,
-          "eligibilityStatus"         -> criterion.eligibilityStatus.toJson,
-          "verifiedEligibilityStatus" -> criterion.verifiedEligibilityStatus.toJson,
-          "isVerified"                -> criterion.isVerified.toJson,
-          "isVisible"                 -> criterion.isVisible.toJson,
-          "lastUpdate"                -> criterion.lastUpdate.toJson
+          "criterionIsDefining"       -> obj.patientCriterion.criterionIsDefining.toJson,
+          "criterionIsCompound"       -> obj.patientCriterion.criterionValue.isEmpty.toJson,
+          "arms"                      -> obj.armList.map(_.armName).toJson,
+          "eligibilityStatus"         -> obj.patientCriterion.eligibilityStatus.toJson,
+          "verifiedEligibilityStatus" -> obj.patientCriterion.verifiedEligibilityStatus.toJson,
+          "isVerified"                -> obj.patientCriterion.isVerified.toJson,
+          "isVisible"                 -> obj.patientCriterion.isVisible.toJson,
+          "lastUpdate"                -> obj.patientCriterion.lastUpdate.toJson
         )
       }
     }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientdefiningcriteria.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientdefiningcriteria.scala
index b97570a..746c7b4 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientdefiningcriteria.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientdefiningcriteria.scala
@@ -2,12 +2,13 @@ package xyz.driver.pdsuidomain.formats.json.sprayformats
 
 import spray.json._
 import xyz.driver.pdsuidomain.entities.PatientLabel
+import xyz.driver.formats.json.labels._
 
 object patientdefiningcriteria {
   import DefaultJsonProtocol._
   import common._
 
-  implicit val patientLabelDefiningCriteriaWriter: JsonWriter[PatientLabel] = new JsonWriter[PatientLabel] {
+  implicit val patientLabelDefiningCriteriaWriter: RootJsonWriter[PatientLabel] = new RootJsonWriter[PatientLabel] {
     override def write(obj: PatientLabel) =
       JsObject(
         "id"    -> obj.id.toJson,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patienteligibletrial.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patienteligibletrial.scala
index 894e453..342d3a8 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patienteligibletrial.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patienteligibletrial.scala
@@ -3,6 +3,7 @@ package xyz.driver.pdsuidomain.formats.json.sprayformats
 import spray.json._
 import xyz.driver.pdsuidomain.entities._
 import xyz.driver.pdsuidomain.services.PatientEligibleTrialService.RichPatientEligibleTrial
+import xyz.driver.formats.json.labels._
 
 object patienteligibletrial {
   import DefaultJsonProtocol._
@@ -21,8 +22,8 @@ object patienteligibletrial {
       case _ => deserializationError(s"Expected Json Object as partial PatientTrialArmGroupView, but got $json")
     }
 
-  implicit val patientEligibleTrialWriter: JsonWriter[RichPatientEligibleTrial] =
-    new JsonWriter[RichPatientEligibleTrial] {
+  implicit val patientEligibleTrialWriter: RootJsonWriter[RichPatientEligibleTrial] =
+    new RootJsonWriter[RichPatientEligibleTrial] {
       override def write(obj: RichPatientEligibleTrial) =
         JsObject(
           "id"                        -> obj.group.id.toJson,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patienthypothesis.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patienthypothesis.scala
index 4f2783c..b8c0058 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patienthypothesis.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patienthypothesis.scala
@@ -2,6 +2,7 @@ package xyz.driver.pdsuidomain.formats.json.sprayformats
 
 import spray.json._
 import xyz.driver.pdsuidomain.entities._
+import xyz.driver.pdsuidomain.services.PatientHypothesisService.RichPatientHypothesis
 
 object patienthypothesis {
   import DefaultJsonProtocol._
@@ -18,18 +19,29 @@ object patienthypothesis {
     case _ => deserializationError(s"Expected Json Object as partial PatientHypothesis, but got $json")
   }
 
-  implicit val patientHypothesisWriter: JsonWriter[(PatientHypothesis, Boolean)] =
-    new JsonWriter[(PatientHypothesis, Boolean)] {
-      override def write(obj: (PatientHypothesis, Boolean)): JsValue = {
-        val patientHypothesis   = obj._1
-        val isRationaleRequired = obj._2
+  implicit val richPatientHypothesisWriter: RootJsonWriter[RichPatientHypothesis] =
+    new RootJsonWriter[RichPatientHypothesis] {
+      override def write(obj: RichPatientHypothesis): JsValue = {
         JsObject(
-          "id"                  -> patientHypothesis.id.toJson,
-          "patientId"           -> patientHypothesis.patientId.toJson,
-          "hypothesisId"        -> patientHypothesis.hypothesisId.toJson,
-          "matchedTrials"       -> patientHypothesis.matchedTrials.toJson,
-          "rationale"           -> patientHypothesis.rationale.toJson,
-          "isRationaleRequired" -> isRationaleRequired.toJson
+          "id"                  -> obj.patientHypothesis.id.toJson,
+          "patientId"           -> obj.patientHypothesis.patientId.toJson,
+          "hypothesisId"        -> obj.patientHypothesis.hypothesisId.toJson,
+          "matchedTrials"       -> obj.patientHypothesis.matchedTrials.toJson,
+          "rationale"           -> obj.patientHypothesis.rationale.toJson,
+          "isRationaleRequired" -> obj.isRequired.toJson
+        )
+      }
+    }
+
+  implicit val patientHypothesisWriter: RootJsonWriter[PatientHypothesis] =
+    new RootJsonWriter[PatientHypothesis] {
+      override def write(obj: PatientHypothesis): JsValue = {
+        JsObject(
+          "id"            -> obj.id.toJson,
+          "patientId"     -> obj.patientId.toJson,
+          "hypothesisId"  -> obj.hypothesisId.toJson,
+          "matchedTrials" -> obj.matchedTrials.toJson,
+          "rationale"     -> obj.rationale.toJson
         )
       }
     }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientissue.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientissue.scala
index 7d35bd1..d325a53 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientissue.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientissue.scala
@@ -40,7 +40,7 @@ object patientissue {
 
   }
 
-  implicit val patientIssueWriter = new JsonWriter[PatientIssue] {
+  implicit val patientIssueWriter = new RootJsonWriter[PatientIssue] {
     override def write(obj: PatientIssue) = JsObject(
       "id"              -> obj.id.toJson,
       "text"            -> obj.text.toJson,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientlabel.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientlabel.scala
index 3b52833..57dca1e 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientlabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientlabel.scala
@@ -1,8 +1,12 @@
 package xyz.driver.pdsuidomain.formats.json.sprayformats
 
 import spray.json._
-import xyz.driver.pdsuicommon.domain.FuzzyValue
+import xyz.driver.entities.labels.LabelValue
 import xyz.driver.pdsuidomain.entities._
+import xyz.driver.pdsuidomain.services.PatientLabelService.RichPatientLabel
+import xyz.driver.formats.json.labels._
+import xyz.driver.pdsuidomain.formats.json.sprayformats.record._
+import xyz.driver.pdsuidomain.formats.json.sprayformats.document._
 
 object patientlabel {
   import DefaultJsonProtocol._
@@ -12,12 +16,12 @@ object patientlabel {
     case JsObject(fields) =>
       val primaryValue = fields
         .get("primaryValue")
-        .map(_.convertTo[Option[FuzzyValue]])
+        .map(_.convertTo[Option[LabelValue]])
         .getOrElse(orig.primaryValue)
 
       val verifiedPrimaryValue = fields
         .get("verifiedPrimaryValue")
-        .map(_.convertTo[Option[FuzzyValue]])
+        .map(_.convertTo[Option[LabelValue]])
         .getOrElse(orig.verifiedPrimaryValue)
 
       orig.copy(
@@ -28,25 +32,23 @@ object patientlabel {
     case _ => deserializationError(s"Expected Json Object as PatientLabel, but got $json")
   }
 
-  implicit val patientLabelWriter: JsonWriter[(PatientLabel, Boolean)] = new JsonWriter[(PatientLabel, Boolean)] {
-    override def write(obj: (PatientLabel, Boolean)): JsValue = {
-      val patientLabel = obj._1
-      val isVerified   = obj._2
+  implicit val richPatientLabelWriter: RootJsonWriter[RichPatientLabel] = new RootJsonWriter[RichPatientLabel] {
+    override def write(obj: RichPatientLabel): JsValue = {
       JsObject(
-        "id"                   -> patientLabel.id.toJson,
-        "labelId"              -> patientLabel.labelId.toJson,
-        "primaryValue"         -> patientLabel.primaryValue.toJson,
-        "verifiedPrimaryValue" -> patientLabel.verifiedPrimaryValue.toJson,
-        "score"                -> patientLabel.score.toJson,
-        "isImplicitMatch"      -> patientLabel.isImplicitMatch.toJson,
-        "isVisible"            -> patientLabel.isVisible.toJson,
-        "isVerified"           -> isVerified.toJson
+        "id"                   -> obj.patientLabel.id.toJson,
+        "labelId"              -> obj.patientLabel.labelId.toJson,
+        "primaryValue"         -> obj.patientLabel.primaryValue.toJson,
+        "verifiedPrimaryValue" -> obj.patientLabel.verifiedPrimaryValue.toJson,
+        "score"                -> obj.patientLabel.score.toJson,
+        "isImplicitMatch"      -> obj.patientLabel.isImplicitMatch.toJson,
+        "isVisible"            -> obj.patientLabel.isVisible.toJson,
+        "isVerified"           -> obj.isVerified.toJson
       )
     }
   }
 
-  implicit val patientLabelEvidenceWriter: JsonWriter[PatientLabelEvidenceView] =
-    new JsonWriter[PatientLabelEvidenceView] {
+  implicit val patientLabelEvidenceWriter: RootJsonWriter[PatientLabelEvidenceView] =
+    new RootJsonWriter[PatientLabelEvidenceView] {
       override def write(evidence: PatientLabelEvidenceView): JsValue =
         JsObject(
           "id"           -> evidence.id.toJson,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/record.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/record.scala
index 8eef44a..65687c1 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/record.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/record.scala
@@ -67,7 +67,6 @@ object record {
     override def write(obj: Duplicate) =
       JsObject(
         "type"              -> "duplicate".toJson,
-        "predicted"         -> obj.predicted.toJson,
         "startPage"         -> obj.startPage.toJson,
         "endPage"           -> obj.endPage.toJson,
         "startOriginalPage" -> obj.startOriginalPage.toJson,
@@ -76,10 +75,6 @@ object record {
 
     override def read(json: JsValue): Duplicate = json match {
       case JsObject(fields) =>
-        val predicted = fields
-          .get("predicted")
-          .map(_.convertTo[Boolean])
-
         val startPage = fields
           .get("startPage")
           .map(_.convertTo[Double])
@@ -101,7 +96,6 @@ object record {
           .map(_.convertTo[Double])
 
         Duplicate(
-          predicted = predicted,
           startPage = startPage,
           endPage = endPage,
           startOriginalPage = startOriginalPage,
@@ -114,27 +108,16 @@ object record {
 
   implicit val reorderMetaFormat: RootJsonFormat[Reorder] = new RootJsonFormat[Reorder] {
     override def write(obj: Reorder) =
-      JsObject(
-        "type"      -> "reorder".toJson,
-        "predicted" -> obj.predicted.toJson,
-        "items"     -> obj.items.toJson
-      )
+      JsObject("type" -> "reorder".toJson, "items" -> obj.items.toJson)
 
     override def read(json: JsValue): Reorder = json match {
       case JsObject(fields) =>
-        val predicted = fields
-          .get("predicted")
-          .map(_.convertTo[Boolean])
-
         val items = fields
           .get("items")
           .map(_.convertTo[Seq[Int]])
           .getOrElse(deserializationError(s"Reorder meta json object does not contain `items` field: $json"))
 
-        Reorder(
-          predicted = predicted,
-          items = items
-        )
+        Reorder(items)
 
       case _ => deserializationError(s"Expected JsObject as Reorder meta of medical record, but got $json")
     }
@@ -142,27 +125,16 @@ object record {
 
   implicit val rotateMetaFormat: RootJsonFormat[Rotation] = new RootJsonFormat[Rotation] {
     override def write(obj: Rotation) =
-      JsObject(
-        "type"      -> "rotation".toJson,
-        "predicted" -> obj.predicted.toJson,
-        "items"     -> obj.items.toJson
-      )
+      JsObject("type" -> "rotation".toJson, "items" -> obj.items.toJson)
 
     override def read(json: JsValue): Rotation = json match {
       case JsObject(fields) =>
-        val predicted = fields
-          .get("predicted")
-          .map(_.convertTo[Boolean])
-
         val items = fields
           .get("items")
           .map(_.convertTo[Map[String, Int]])
           .getOrElse(deserializationError(s"Rotation meta json object does not contain `items` field: $json"))
 
-        Rotation(
-          predicted = predicted,
-          items = items
-        )
+        Rotation(items = items)
 
       case _ => deserializationError(s"Expected JsObject as Rotation meta of medical record, but got $json")
     }
@@ -233,8 +205,6 @@ object record {
             caseId = None,
             physician = None,
             meta = None,
-            predictedMeta = None,
-            predictedDocuments = None,
             lastUpdate = LocalDateTime.now()
           )
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/trial.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/trial.scala
index a778000..b25ed1d 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/trial.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/trial.scala
@@ -9,8 +9,8 @@ import xyz.driver.pdsuidomain.entities._
 
 object trial {
   import DefaultJsonProtocol._
-  import common._
   import Trial._
+  import common._
 
   implicit val trialStatusFormat = new EnumJsonFormat[Status](
     "New"            -> Status.New,
@@ -24,13 +24,7 @@ object trial {
     "Archived"       -> Status.Archived
   )
 
-  implicit val conditionFormat = new EnumJsonFormat[Condition](
-    "Breast"   -> Condition.Breast,
-    "Lung"     -> Condition.Lung,
-    "Prostate" -> Condition.Prostate
-  )
-
-  implicit val trialWriter: JsonWriter[Trial] = new JsonWriter[Trial] {
+  implicit val trialWriter: RootJsonWriter[Trial] = new RootJsonWriter[Trial] {
     override def write(obj: Trial) =
       JsObject(
         "id"                    -> obj.id.toJson,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/trialissue.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/trialissue.scala
index 572f44d..d1ca191 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/trialissue.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/trialissue.scala
@@ -44,7 +44,7 @@ object trialissue {
 
   }
 
-  implicit val trialIssueWriter = new JsonWriter[TrialIssue] {
+  implicit val trialIssueWriter = new RootJsonWriter[TrialIssue] {
     override def write(obj: TrialIssue) = JsObject(
       "id"              -> obj.id.toJson,
       "text"            -> obj.text.toJson,
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 fbf506b..133a2c8 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
@@ -2,11 +2,11 @@ package xyz.driver.pdsuidomain.formats.json.trial
 
 import java.time.{ZoneId, ZonedDateTime}
 import java.util.UUID
-import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId}
 
-import xyz.driver.pdsuidomain.entities.Trial
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
+import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId}
+import xyz.driver.pdsuidomain.entities.Trial
 
 final case class ApiTrial(id: String,
                           externalId: UUID,