Merge branch 'master' into PDSUI-2345

32 files changed, 133 insertions, 176 deletions

diff --git a/build.sbt b/build.sbt
index f726690..2cccdb4 100644
--- a/build.sbt
+++ b/build.sbt
@@ -3,14 +3,12 @@ import Keys._
 
 lazy val core = (project in file("."))
   .driverLibrary("pds-ui-common")
-  .settings(scalastyleSettings ++ wartRemoverSettings ++ formatSettings)
-  .settings(wartremoverErrors in (Compile, compile) --= Seq(
-    Wart.ImplicitConversion, Wart.MutableDataStructures, Wart.TraversableOps, Wart.OptionPartial))
+  .settings(lintingSettings)
+  .settings(scalacOptions -= "-Xfatal-warnings") // this is needed to ignore unused implicits that are actually used in scala 2.11
   .settings(sources in (Compile, doc) := Seq.empty, publishArtifact in (Compile, packageDoc) := false)
   .settings(libraryDependencies ++= Seq(
-    "com.fasterxml.jackson.module"      %% "jackson-module-scala"   % "2.8.3",
     "com.github.pureconfig"             %% "pureconfig"             % "0.7.2",
-    "com.lihaoyi"                       %% "fastparse"              % "0.3.7",
+    "com.lihaoyi"                       %% "fastparse"              % "1.0.0",
     "com.typesafe.akka"                 %% "akka-http"              % "10.0.10",
     "com.typesafe.scala-logging"        %% "scala-logging"          % "3.5.0",
     "io.getquill"                       %% "quill-jdbc"             % "1.2.1",
@@ -25,7 +23,6 @@ lazy val core = (project in file("."))
     "com.typesafe"                      % "config"                  % "1.3.0",
     "org.asynchttpclient"               % "async-http-client"       % "2.0.24",
     "org.slf4j"                         % "slf4j-api"               % "1.7.21",
-    "ai.x"                              %% "diff"                   % "1.2.0-get-simple-name-fix" % "test",
     "org.scalacheck"                    %% "scalacheck"              % "1.13.4" % "test",
     "org.scalatest"                     %% "scalatest"              % "3.0.1"  % "test"
   ))
diff --git a/project/build.properties b/project/build.properties
index 3507256..b7dd3cb 100644
--- a/project/build.properties
+++ b/project/build.properties
@@ -1,4 +1 @@
-#Activator-generated Properties
-#Wed Jul 06 16:08:49 PDT 2016
-template.uuid=a675a7df-bee3-48df-9eaa-688d99e5814e
-sbt.version=0.13.16
+sbt.version=1.0.2
diff --git a/project/plugins.sbt b/project/plugins.sbt
index 83fdd9a..30a0355 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -1,4 +1,4 @@
 resolvers += "releases" at "https://drivergrp.jfrog.io/drivergrp/releases"
 credentials += Credentials("Artifactory Realm", "drivergrp.jfrog.io", "sbt-publisher", "ANC-d8X-Whm-USS")
 
-addSbtPlugin("xyz.driver" % "sbt-settings" % "0.7.39")
+addSbtPlugin("xyz.driver" % "sbt-settings" % "1.0.3")
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala b/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala
index a2c5a75..8adf629 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/Sorting.scala
@@ -40,7 +40,7 @@ object Sorting {
 
   def filter(sorting: Sorting, p: Dimension => Boolean): Seq[Dimension] = sorting match {
     case x: Dimension if p(x) => Seq(x)
-    case x: Dimension         => Seq.empty
+    case _: Dimension         => Seq.empty
     case Sequential(xs)       => xs.filter(p)
   }
 
@@ -51,7 +51,7 @@ object Sorting {
       r += f(x)
       r.result()
 
-    case x: Dimension   => bf.apply().result()
+    case _: Dimension   => bf.apply().result()
     case Sequential(xs) => xs.collect(f)
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParser.scala b/src/main/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParser.scala
index 718a42d..aeb6c16 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParser.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParser.scala
@@ -5,7 +5,6 @@ import java.util.UUID
 import xyz.driver.pdsuicommon.utils.Implicits.{toCharOps, toStringOps}
 import fastparse.all._
 import fastparse.core.Parsed
-import fastparse.parsers.Intrinsics.CharPred
 import xyz.driver.pdsuicommon.db.{SearchFilterBinaryOperation, SearchFilterExpr, SearchFilterNAryOperation}
 import xyz.driver.pdsuicommon.utils.Utils._
 
@@ -150,14 +149,14 @@ object SearchFilterParser {
 
       case head :: Nil =>
         atomParser.parse(head) match {
-          case Parsed.Success(x, _) => x
-          case e: Parsed.Failure    => throw new ParseQueryArgException("filters" -> formatFailure(1, e))
+          case Parsed.Success(x, _)    => x
+          case e: Parsed.Failure[_, _] => throw new ParseQueryArgException("filters" -> formatFailure(1, e))
         }
 
       case xs =>
         val parsed = xs.map(x => atomParser.parse(x))
         val failures: Seq[String] = parsed.zipWithIndex.collect {
-          case (e: Parsed.Failure, index) => formatFailure(index, e)
+          case (e: Parsed.Failure[_, _], index) => formatFailure(index, e)
         }
 
         if (failures.isEmpty) {
@@ -172,8 +171,8 @@ object SearchFilterParser {
     }
   }
 
-  private def formatFailure(sectionIndex: Int, e: Parsed.Failure): String = {
-    s"section $sectionIndex: ${ParseError.msg(e.extra.input, e.extra.traced.expected, e.index)}"
+  private def formatFailure(sectionIndex: Int, e: Parsed.Failure[_, _]): String = {
+    s"section $sectionIndex: ${fastparse.core.ParseError.msg(e.extra.input, e.extra.traced.expected, e.index)}"
   }
 
 }
diff --git a/src/main/scala/xyz/driver/pdsuicommon/parsers/SortingParser.scala b/src/main/scala/xyz/driver/pdsuicommon/parsers/SortingParser.scala
index 4bfc669..a04d278 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/parsers/SortingParser.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/parsers/SortingParser.scala
@@ -49,7 +49,7 @@ object SortingParser {
         val parser = sequentialSortingParser(validDimensions.toSeq)
         parser.parse(rawSorting) match {
           case Parsed.Success(x, _) => x
-          case e: Parsed.Failure =>
+          case e: Parsed.Failure[_, _] =>
             throw new ParseQueryArgException("sort" -> formatFailure(e))
         }
 
@@ -57,8 +57,8 @@ object SortingParser {
     }
   }
 
-  private def formatFailure(e: Parsed.Failure): String = {
-    ParseError.msg(e.extra.input, e.extra.traced.expected, e.index)
+  private def formatFailure(e: Parsed.Failure[_, _]): String = {
+    fastparse.core.ParseError.msg(e.extra.input, e.extra.traced.expected, e.index)
   }
 
 }
diff --git a/src/main/scala/xyz/driver/pdsuicommon/utils/ServiceUtils.scala b/src/main/scala/xyz/driver/pdsuicommon/utils/ServiceUtils.scala
index cf53e6b..68070f4 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/utils/ServiceUtils.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/utils/ServiceUtils.scala
@@ -15,8 +15,8 @@ object ServiceUtils extends PhiLogging {
 
   def findEqFilter(filter: SearchFilterExpr, dimension: Dimension): Option[SearchFilterExpr] = {
     filter.find {
-      case Atom.Binary(dimension, Eq, _) => true
-      case _                             => false
+      case Atom.Binary(`dimension`, Eq, _) => true
+      case _                               => false
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/Document.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/Document.scala
index 471d345..95710be 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/Document.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/Document.scala
@@ -7,7 +7,6 @@ import com.fasterxml.jackson.core.{JsonGenerator, JsonParser}
 import com.fasterxml.jackson.databind._
 import com.fasterxml.jackson.databind.annotation.{JsonDeserialize, JsonSerialize}
 import xyz.driver.core.auth.User
-import xyz.driver.pdsuicommon.compat.Implicits._
 import xyz.driver.pdsuicommon.domain._
 import xyz.driver.pdsuicommon.logging._
 import xyz.driver.pdsuicommon.utils.Utils
@@ -411,31 +410,31 @@ object Document {
 
   val validator: Validator[Document, Document] = { input =>
     for {
-      typeId <- Validators.nonEmpty("typeId")(input.typeId)
+      typeId <- Validators.nonEmpty("typeId")(input.typeId).right
 
-      providerTypeId <- Validators.nonEmpty("providerTypeId")(input.providerTypeId)
+      providerTypeId <- Validators.nonEmpty("providerTypeId")(input.providerTypeId).right
 
-      institutionName <- Validators.nonEmpty("institutionName")(input.institutionName)
+      institutionName <- Validators.nonEmpty("institutionName")(input.institutionName).right
 
-      meta <- Validators.nonEmpty("meta")(input.meta)
+      meta <- Validators.nonEmpty("meta")(input.meta).right
 
-      startDate <- Validators.nonEmpty("startDate")(input.startDate)
+      startDate <- Validators.nonEmpty("startDate")(input.startDate).right
 
-      isOrderRight <- input.endDate match {
+      isOrderRight <- (input.endDate match {
                        case Some(endDate) if startDate.isAfter(endDate) =>
                          Validators.fail("The start date should be less, than the end one")
 
                        case _ => Validators.success(true)
-                     }
+                     }).right
 
       areDatesInThePast <- {
-        val dates      = List(input.startDate, input.endDate).flatten
-        val now        = LocalDate.now()
+        val dates = List(input.startDate, input.endDate).flatten
+        val now = LocalDate.now()
         val hasInvalid = dates.exists(_.isAfter(now))
 
         if (hasInvalid) Validators.fail("Dates should be in the past")
         else Validators.success(true)
-      }
+      }.right
     } yield input
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientCriterion.scala
index 7027eef..193e8cb 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientCriterion.scala
@@ -19,17 +19,16 @@ object PatientCriterion {
   /**
     * @see https://driverinc.atlassian.net/wiki/display/MTCH/EV+Business+Process
     */
-  def getEligibilityStatus(criterionValue: Option[Boolean], primaryValue: Option[LabelValue]): Option[LabelValue] = {
+  def getEligibilityStatus(criterionValue: Option[Boolean], primaryValue: LabelValue): LabelValue = {
     primaryValue match {
-      case None                              => None
-      case Some(LabelValue.Maybe)            => Some(LabelValue.Maybe)
-      case Some(_) if criterionValue.isEmpty => Some(LabelValue.Maybe)
-      case Some(status) =>
-        Some(
+      case LabelValue.Unknown          => LabelValue.Unknown
+      case LabelValue.Maybe            => LabelValue.Maybe
+      case _ if criterionValue.isEmpty => LabelValue.Maybe
+      case status =>
+        LabelValue.fromBoolean(
           LabelValue.fromBoolean(
-            LabelValue.fromBoolean(
-              criterionValue.getOrElse(throw new IllegalArgumentException("Criterion should not be empty"))) == status
-          ))
+            criterionValue.getOrElse(throw new IllegalArgumentException("Criterion should not be empty"))) == status
+        )
     }
   }
 
@@ -48,13 +47,14 @@ final case class PatientCriterion(id: LongId[PatientCriterion],
                                   criterionText: String,
                                   criterionValue: Option[Boolean],
                                   criterionIsDefining: Boolean,
-                                  eligibilityStatus: Option[LabelValue],
-                                  verifiedEligibilityStatus: Option[LabelValue],
+                                  eligibilityStatus: LabelValue,
+                                  verifiedEligibilityStatus: LabelValue,
                                   isVerified: Boolean,
                                   isVisible: Boolean,
                                   lastUpdate: LocalDateTime,
                                   inclusion: Option[Boolean]) {
-  def isIneligibleForEv: Boolean = eligibilityStatus.contains(LabelValue.No) && isVerified
+  import scalaz.syntax.equal._
+  def isIneligibleForEv: Boolean = eligibilityStatus === LabelValue.No && isVerified
 }
 
 object PatientCriterionArm {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientEligibleTrial.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientEligibleTrial.scala
index ff272a8..179056a 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientEligibleTrial.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientEligibleTrial.scala
@@ -38,22 +38,22 @@ object PatientTrialArmGroup {
   /**
     * @see https://driverinc.atlassian.net/wiki/display/DMPD/EV+Business+Process
     */
-  def getEligibilityStatusForRc(criterionList: TraversableOnce[PatientCriterion]): Option[LabelValue] = {
-    def isEligible: Boolean   = criterionList.forall(_.verifiedEligibilityStatus.contains(LabelValue.Yes))
-    def isIneligible: Boolean = criterionList.exists(_.verifiedEligibilityStatus.contains(LabelValue.No))
-    def isUnknown: Boolean    = criterionList.forall(_.verifiedEligibilityStatus.isEmpty)
+  def getEligibilityStatusForRc(criterionList: TraversableOnce[PatientCriterion]): LabelValue = {
+    def isEligible: Boolean   = criterionList.forall(_.verifiedEligibilityStatus == LabelValue.Yes)
+    def isIneligible: Boolean = criterionList.exists(_.verifiedEligibilityStatus == LabelValue.No)
+    def isUnknown: Boolean    = criterionList.forall(_.verifiedEligibilityStatus == LabelValue.Unknown)
 
-    if (isEligible) Some(LabelValue.Yes)
-    else if (isIneligible) Some(LabelValue.No)
-    else if (isUnknown) None
-    else Some(LabelValue.Maybe)
+    if (isEligible) LabelValue.Yes
+    else if (isIneligible) LabelValue.No
+    else if (isUnknown) LabelValue.Unknown
+    else LabelValue.Maybe
   }
 }
 
 final case class PatientTrialArmGroup(id: LongId[PatientTrialArmGroup],
                                       eligibleTrialId: UuidId[PatientEligibleTrial],
-                                      eligibilityStatus: Option[LabelValue],
-                                      verifiedEligibilityStatus: Option[LabelValue],
+                                      eligibilityStatus: LabelValue,
+                                      verifiedEligibilityStatus: LabelValue,
                                       isVerified: Boolean)
 
 object PatientTrialArmGroupView {
@@ -70,8 +70,8 @@ final case class PatientTrialArmGroupView(id: LongId[PatientTrialArmGroup],
                                           patientId: UuidId[Patient],
                                           trialId: StringId[Trial],
                                           hypothesisId: UuidId[Hypothesis],
-                                          eligibilityStatus: Option[LabelValue],
-                                          verifiedEligibilityStatus: Option[LabelValue],
+                                          eligibilityStatus: LabelValue,
+                                          verifiedEligibilityStatus: LabelValue,
                                           isVerified: Boolean) {
 
   def applyTo(trialArmGroup: PatientTrialArmGroup) = {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientLabel.scala
index 4c0f4ef..df86175 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientLabel.scala
@@ -17,8 +17,8 @@ final case class PatientLabel(id: LongId[PatientLabel],
                               patientId: UuidId[Patient],
                               labelId: LongId[Label],
                               score: Int,
-                              primaryValue: Option[LabelValue],
-                              verifiedPrimaryValue: Option[LabelValue],
+                              primaryValue: LabelValue,
+                              verifiedPrimaryValue: LabelValue,
                               isImplicitMatch: Boolean,
                               isVisible: Boolean)
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/TrialHistory.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/TrialHistory.scala
index c66048b..cc96cbd 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/TrialHistory.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/TrialHistory.scala
@@ -90,4 +90,5 @@ final case class TrialHistory(id: LongId[TrialHistory],
                               trialId: StringId[Trial],
                               state: State,
                               action: Action,
-                              created: LocalDateTime = LocalDateTime.now(ZoneId.of("Z")))
+                              created: LocalDateTime = LocalDateTime.now(ZoneId.of("Z")),
+                              comment: Option[String] = None)
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/recordprocessing.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/recordprocessing.scala
index 5903dc8..d3d76b8 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/recordprocessing.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/recordprocessing.scala
@@ -264,7 +264,7 @@ object recordprocessing {
     )
   }
 
-  def nextExtractedDataLabel(dataId: LongId[ExtractedData]): ExtractedDataLabel = {
+  def nextExtractedDataLabel(): ExtractedDataLabel = {
     ExtractedDataLabel(
       id = nextLongId[ExtractedDataLabel],
       dataId = nextLongId[ExtractedData],
@@ -280,7 +280,7 @@ object recordprocessing {
       extractedData = extractedData,
       labels = List.fill(
         nextInt(maxItemsInCollectionNumber)
-      )(nextExtractedDataLabel(extractedData.id))
+      )(nextExtractedDataLabel())
     )
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/treatmentmatching.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/treatmentmatching.scala
index 441c1db..f2d6a1b 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/treatmentmatching.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/treatmentmatching.scala
@@ -62,8 +62,8 @@ object treatmentmatching {
     patientId = nextUuidId[Patient],
     labelId = nextLongId[Label],
     score = generators.nextInt(100),
-    primaryValue = generators.nextOption(fakes.entities.labels.nextLabelValue()),
-    verifiedPrimaryValue = generators.nextOption(fakes.entities.labels.nextLabelValue()),
+    primaryValue = fakes.entities.labels.nextLabelValue(),
+    verifiedPrimaryValue = fakes.entities.labels.nextLabelValue(),
     isImplicitMatch = generators.nextBoolean(),
     isVisible = generators.nextBoolean()
   )
@@ -82,8 +82,8 @@ object treatmentmatching {
     criterionText = generators.nextString(),
     criterionValue = generators.nextOption(generators.nextBoolean()),
     criterionIsDefining = generators.nextBoolean(),
-    eligibilityStatus = generators.nextOption(fakes.entities.labels.nextLabelValue()),
-    verifiedEligibilityStatus = generators.nextOption(fakes.entities.labels.nextLabelValue()),
+    eligibilityStatus = fakes.entities.labels.nextLabelValue(),
+    verifiedEligibilityStatus = fakes.entities.labels.nextLabelValue(),
     isVerified = generators.nextBoolean(),
     isVisible = generators.nextBoolean(),
     lastUpdate = nextLocalDateTime,
@@ -139,8 +139,8 @@ object treatmentmatching {
     patientId = nextUuidId[Patient],
     trialId = trialId,
     hypothesisId = nextUuidId[Hypothesis],
-    eligibilityStatus = generators.nextOption(fakes.entities.labels.nextLabelValue()),
-    verifiedEligibilityStatus = generators.nextOption(fakes.entities.labels.nextLabelValue()),
+    eligibilityStatus = fakes.entities.labels.nextLabelValue(),
+    verifiedEligibilityStatus = fakes.entities.labels.nextLabelValue(),
     isVerified = generators.nextBoolean()
   )
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/trialcuration.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/trialcuration.scala
index 94bc27a..1e4ad51 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/trialcuration.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/trialcuration.scala
@@ -123,7 +123,8 @@ object trialcuration {
     trialId = nextStringId[Trial],
     state = nextTrialState,
     action = nextTrialAction,
-    created = nextLocalDateTime
+    created = nextLocalDateTime,
+    comment = generators.nextOption(generators.nextString())
   )
 
   def nextHypothesis(): Hypothesis = Hypothesis(
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document.scala
index 8ab6f13..66e95f3 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document.scala
@@ -141,6 +141,14 @@ object document {
           .map(_.convertTo[LongId[MedicalRecord]])
           .getOrElse(deserializationError(s"Document create json object does not contain `recordId` field: $json"))
 
+        val status = fields
+          .get("status")
+          .flatMap(_.convertTo[Option[Document.Status]])
+
+        val previousStatus = fields
+          .get("previousStatus")
+          .flatMap(_.convertTo[Option[Document.Status]])
+
         val physician = fields
           .get("physician")
           .flatMap(_.convertTo[Option[String]])
@@ -149,6 +157,10 @@ object document {
           .get("typeId")
           .flatMap(_.convertTo[Option[LongId[DocumentType]]])
 
+        val requiredType = fields
+          .get("requiredType")
+          .flatMap(_.convertTo[Option[Document.RequiredType]])
+
         val provider = fields
           .get("provider")
           .flatMap(_.convertTo[Option[String]])
@@ -173,25 +185,33 @@ object document {
           .get("endDate")
           .flatMap(_.convertTo[Option[LocalDate]])
 
+        val lastUpdate = fields
+          .get("lastUpdate")
+          .flatMap(_.convertTo[Option[LocalDateTime]])
+
+        val labelVersion = fields
+          .get("labelVersion")
+          .flatMap(_.convertTo[Option[Int]])
+
         Document(
           id = id.getOrElse(LongId(0)),
           recordId = recordId,
-          status = Document.Status.New,
+          status = status.getOrElse(Document.Status.New),
           physician = physician,
           typeId = typeId,
           startDate = startDate,
           endDate = endDate,
           providerName = provider,
           providerTypeId = providerTypeId,
-          requiredType = None,
+          requiredType = requiredType,
           institutionName = institutionName,
           meta = meta,
-          previousStatus = None,
+          previousStatus = previousStatus,
           assignee = None,
           previousAssignee = None,
           lastActiveUserId = None,
-          lastUpdate = LocalDateTime.MIN,
-          labelVersion = 0
+          lastUpdate = lastUpdate.getOrElse(LocalDateTime.MIN),
+          labelVersion = labelVersion.getOrElse(0)
         )
 
       case _ => deserializationError(s"Expected Json Object as Document, but got $json")
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientcriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientcriterion.scala
index b5696f7..1004c5b 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientcriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientcriterion.scala
@@ -15,12 +15,12 @@ object patientcriterion {
     case JsObject(fields) =>
       val eligibilityStatus = fields
         .get("eligibilityStatus")
-        .map(_.convertTo[Option[LabelValue]])
+        .map(_.convertTo[LabelValue])
         .getOrElse(orig.eligibilityStatus)
 
       val verifiedEligibilityStatus = fields
         .get("verifiedEligibilityStatus")
-        .map(_.convertTo[Option[LabelValue]])
+        .map(_.convertTo[LabelValue])
         .getOrElse(orig.verifiedEligibilityStatus)
 
       orig.copy(
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientdefiningcriteria.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientdefiningcriteria.scala
index 0b4fbae..a67115c 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientdefiningcriteria.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientdefiningcriteria.scala
@@ -5,7 +5,6 @@ import xyz.driver.formats.json.labels._
 import xyz.driver.pdsuidomain.entities.PatientLabel
 
 object patientdefiningcriteria {
-  import DefaultJsonProtocol._
   import common._
 
   implicit val patientLabelDefiningCriteriaWriter: RootJsonWriter[PatientLabel] = new RootJsonWriter[PatientLabel] {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientlabel.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientlabel.scala
index d944e42..6499318 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientlabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientlabel.scala
@@ -17,12 +17,12 @@ object patientlabel {
     case JsObject(fields) =>
       val primaryValue = fields
         .get("primaryValue")
-        .map(_.convertTo[Option[LabelValue]])
+        .map(_.convertTo[LabelValue])
         .getOrElse(orig.primaryValue)
 
       val verifiedPrimaryValue = fields
         .get("verifiedPrimaryValue")
-        .map(_.convertTo[Option[LabelValue]])
+        .map(_.convertTo[LabelValue])
         .getOrElse(orig.verifiedPrimaryValue)
 
       orig.copy(
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/trialhistory.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/trialhistory.scala
index cc01dd1..c8df1d8 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/trialhistory.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/trialhistory.scala
@@ -25,6 +25,6 @@ object trialhistory {
     "Archive"  -> Action.Archive
   )
 
-  implicit val trialHistoryFormat: RootJsonFormat[TrialHistory] = jsonFormat6(TrialHistory.apply)
+  implicit val trialHistoryFormat: RootJsonFormat[TrialHistory] = jsonFormat7(TrialHistory.apply)
 
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/PatientCriterionService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/PatientCriterionService.scala
index 21ec73a..68e7b50 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/PatientCriterionService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/PatientCriterionService.scala
@@ -20,7 +20,7 @@ object PatientCriterionService {
                                          isVerified: Option[Boolean]) {
     def applyTo(orig: PatientCriterion) = {
       orig.copy(
-        eligibilityStatus = eligibilityStatus.orElse(orig.eligibilityStatus),
+        eligibilityStatus = eligibilityStatus.getOrElse(orig.eligibilityStatus),
         isVerified = isVerified.getOrElse(orig.isVerified)
       )
     }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/TrialService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/TrialService.scala
index 2ff77f2..4d61342 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/TrialService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/TrialService.scala
@@ -144,7 +144,7 @@ trait TrialService {
   def resolve(origTrial: Trial)(
           implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply]
 
-  def archive(origTrial: Trial)(
+  def archive(origTrial: Trial, comment: Option[String])(
           implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply]
 
   def unassign(origTrial: Trial)(
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeTrialService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeTrialService.scala
index 7eae626..7d44309 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeTrialService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeTrialService.scala
@@ -117,7 +117,7 @@ class FakeTrialService extends TrialService {
           implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply] =
     update(origTrial, origTrial)
 
-  def archive(origTrial: Trial)(
+  def archive(origTrial: Trial, comment: Option[String])(
           implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply] =
     update(origTrial, origTrial)
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala
index e978775..4654c2e 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala
@@ -101,10 +101,16 @@ class RestTrialService(transport: ServiceTransport, baseUri: Uri)(implicit prote
     }
   }
 
-  private def singleAction(origTrial: Trial, action: String)(
+  private def singleAction(origTrial: Trial, action: String, comment: Option[String] = None)(
           implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply] = {
+
+    val query = comment match {
+      case Some(s) => Seq("comment" -> s)
+      case None    => Seq.empty[(String, String)]
+    }
+
     val id      = origTrial.id.id
-    val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/trial/$id/$action"))
+    val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/trial/$id/$action", query))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
       reply    <- apiResponse[Trial](response)
@@ -116,21 +122,27 @@ class RestTrialService(transport: ServiceTransport, baseUri: Uri)(implicit prote
   def start(origTrial: Trial)(
           implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply] =
     singleAction(origTrial, "start")
+
   def submit(origTrial: Trial)(
           implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply] =
     singleAction(origTrial, "submit")
+
   def restart(origTrial: Trial)(
           implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply] =
     singleAction(origTrial, "restart")
+
   def flag(origTrial: Trial)(
           implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply] =
     singleAction(origTrial, "flag")
+
   def resolve(origTrial: Trial)(
           implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply] =
     singleAction(origTrial, "resolve")
-  def archive(origTrial: Trial)(
+
+  def archive(origTrial: Trial, comment: Option[String])(
           implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply] =
-    singleAction(origTrial, "archive")
+    singleAction(origTrial, "archive", comment)
+
   def unassign(origTrial: Trial)(
           implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply] =
     singleAction(origTrial, "unassign")
diff --git a/src/test/scala/xyz/driver/pdsuicommon/logging/PhiStringContextSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/logging/PhiStringContextSuite.scala
index eb9d9b4..8fd783f 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/logging/PhiStringContextSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/logging/PhiStringContextSuite.scala
@@ -4,7 +4,7 @@ import org.scalatest.FreeSpecLike
 
 class PhiStringContextSuite extends FreeSpecLike {
 
-  class Foo(x: Int, y: String) {
+  case class Foo(x: Int, y: String) {
     val z: Boolean = true
   }
 
diff --git a/src/test/scala/xyz/driver/pdsuicommon/parsers/TestUtils.scala b/src/test/scala/xyz/driver/pdsuicommon/parsers/TestUtils.scala
index 09b60ed..8ab2131 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/parsers/TestUtils.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/parsers/TestUtils.scala
@@ -21,7 +21,7 @@ object TestUtils {
       MatchResult(
         left.isFailure && left.failed.get.getClass == ct.runtimeClass,
         left match {
-          case Success(x) => s"$left did not fail"
+          case Success(_) => s"$left did not fail"
           case Failure(e) =>
             s"$left did fail with ${Utils.getClassSimpleName(e.getClass)}, " +
               s"not ${Utils.getClassSimpleName(ct.runtimeClass)}"
@@ -45,7 +45,7 @@ object TestUtils {
 
     def failureProp: Prop = self match {
       case Success(x) => false :| s"invalid: $x"
-      case Failure(e) => true
+      case Failure(_) => true
     }
 
   }
diff --git a/src/test/scala/xyz/driver/pdsuicommon/utils/DiffUtils.scala b/src/test/scala/xyz/driver/pdsuicommon/utils/DiffUtils.scala
deleted file mode 100644
index 156cb08..0000000
--- a/src/test/scala/xyz/driver/pdsuicommon/utils/DiffUtils.scala
+++ /dev/null
@@ -1,68 +0,0 @@
-package xyz.driver.pdsuicommon.utils
-
-import java.net.URI
-import java.time.{LocalDate, LocalDateTime}
-
-import ai.x.diff._
-import org.scalatest.Assertions
-import xyz.driver.pdsuidomain.entities.{Document, ExtractedData, MedicalRecord}
-
-import scala.io.AnsiColor
-
-trait DiffUtils { this: Assertions =>
-
-  def assertIdentical[T: DiffShow](left: T, right: T): Unit = {
-    val diff = DiffShow.diff(left, right)
-    assert(diff.isIdentical, s"\n${AnsiColor.RESET}$diff") // reset red color
-  }
-
-  implicit def localTimeDiffShow: DiffShow[LocalDateTime] = new DiffShow[LocalDateTime] {
-    def show(x: LocalDateTime): String = s"LocalTime($x)"
-    def diff(left: LocalDateTime, right: LocalDateTime): Comparison = {
-      if (left.isEqual(right)) Identical(show(left))
-      else Different(showChange(left, right))
-    }
-  }
-
-  implicit def localDateDiffShow: DiffShow[LocalDate] = new DiffShow[LocalDate] {
-    def show(x: LocalDate): String = s"LocalDate($x)"
-    def diff(left: LocalDate, right: LocalDate): Comparison = {
-      if (left.isEqual(right)) Identical(show(left))
-      else Different(showChange(left, right))
-    }
-  }
-
-  implicit def urlDiffShow: DiffShow[URI] = new DiffShow[URI] {
-    def show(x: URI): String = s"URI($x)"
-    def diff(left: URI, right: URI): Comparison = {
-      if (left.equals(right)) Identical(show(left))
-      else Different(showChange(left, right))
-    }
-  }
-
-  implicit def metaDiffShow: DiffShow[MedicalRecord.Meta] = new DiffShow[MedicalRecord.Meta] {
-    def show(x: MedicalRecord.Meta): String = s"MedicalRecord.Meta($x)"
-    def diff(left: MedicalRecord.Meta, right: MedicalRecord.Meta): Comparison = {
-      if (left.equals(right)) Identical(show(left))
-      else Different(showChange(left, right))
-    }
-  }
-
-  implicit def extractedDataMetaDiffShow: DiffShow[ExtractedData.Meta] = new DiffShow[ExtractedData.Meta] {
-    def show(x: ExtractedData.Meta): String = s"ExtractedData.Meta($x)"
-    def diff(left: ExtractedData.Meta, right: ExtractedData.Meta): Comparison = {
-      if (left.equals(right)) Identical(show(left))
-      else Different(showChange(left, right))
-    }
-  }
-
-  implicit def documentDiffShow: DiffShow[Document] = new DiffShow[Document] {
-    def show(x: Document): String = s"Document($x)"
-
-    def diff(left: Document, right: Document): Comparison = {
-      if (left == right) Identical(show(left))
-      else Different(showChange(left, right))
-    }
-  }
-
-}
diff --git a/src/test/scala/xyz/driver/pdsuidomain/DocumentSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/DocumentSuite.scala
index 63c4aa2..ccd5a3a 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/DocumentSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/DocumentSuite.scala
@@ -7,10 +7,9 @@ import org.scalatest.FreeSpecLike
 import org.scalatest.concurrent.ScalaFutures
 import org.scalatest.time.{Millis, Span}
 import xyz.driver.pdsuicommon.domain.{LongId, TextJson}
-import xyz.driver.pdsuicommon.utils.DiffUtils
 import xyz.driver.pdsuidomain.entities.Document
 
-class DocumentSuite extends FreeSpecLike with DiffUtils with ScalaFutures {
+class DocumentSuite extends FreeSpecLike with ScalaFutures {
 
   implicit val defaultPatience: PatienceConfig =
     PatienceConfig(timeout = Span(1000, Millis), interval = Span(20, Millis))
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/PatientCriterionFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/PatientCriterionFormatSuite.scala
index e0f96bb..94d80c9 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/PatientCriterionFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/PatientCriterionFormatSuite.scala
@@ -22,8 +22,8 @@ class PatientCriterionFormatSuite extends FlatSpec with Matchers {
       criterionText = "criterion text",
       criterionValue = Some(true),
       criterionIsDefining = false,
-      eligibilityStatus = Some(LabelValue.Yes),
-      verifiedEligibilityStatus = None,
+      eligibilityStatus = LabelValue.Yes,
+      verifiedEligibilityStatus = LabelValue.Unknown,
       isVisible = true,
       isVerified = true,
       lastUpdate = LocalDateTime.parse("2017-08-10T18:00:00"),
@@ -39,12 +39,12 @@ class PatientCriterionFormatSuite extends FlatSpec with Matchers {
     writtenJson should be(
       """{"isVerified":true,"patientLabelId":1,"lastUpdate":"2017-08-10T18:00Z","trialId":0,
          "armList":[{"patientCriterionId":1,"armId":31,"armName":"arm 31"},{"patientCriterionId":1,
-         "armId":32,"armName":"arm 32"}],"eligibilityStatus":"Yes","id":1,"nctId":"NCT00001",
+         "armId":32,"armName":"arm 32"}],"eligibilityStatus":"Yes","verifiedEligibilityStatus":"Unknown","id":1,"nctId":"NCT00001",
          "criterionId":101,"criterionValue":true,"criterionIsDefining":false,"labelId":21,
          "isVisible":true,"criterionText":"criterion text","inclusion":true}""".parseJson)
 
     val updatePatientCriterionJson      = """{"verifiedEligibilityStatus":"No"}""".parseJson
-    val expectedUpdatedPatientCriterion = orig.copy(verifiedEligibilityStatus = Some(LabelValue.No))
+    val expectedUpdatedPatientCriterion = orig.copy(verifiedEligibilityStatus = LabelValue.No)
     val parsedUpdatePatientCriterion    = applyUpdateToPatientCriterion(updatePatientCriterionJson, orig)
     parsedUpdatePatientCriterion should be(expectedUpdatedPatientCriterion)
 
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/PatientEligibleTrialFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/PatientEligibleTrialFormatSuite.scala
index b5fbf3f..faef0f6 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/PatientEligibleTrialFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/PatientEligibleTrialFormatSuite.scala
@@ -38,8 +38,8 @@ class PatientEligibleTrialFormatSuite extends FlatSpec with Matchers {
       patientId = UuidId("748b5884-3528-4cb9-904b-7a8151d6e343"),
       trialId = StringId("NCT000001"),
       hypothesisId = UuidId("e76e2fc4-a29c-44fb-a81b-8856d06bb1d4"),
-      eligibilityStatus = Some(LabelValue.Yes),
-      verifiedEligibilityStatus = Some(LabelValue.Yes),
+      eligibilityStatus = LabelValue.Yes,
+      verifiedEligibilityStatus = LabelValue.Yes,
       isVerified = false
     )
     val arms = List(
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/PatientLabelFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/PatientLabelFormatSuite.scala
index b83aad1..289de53 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/PatientLabelFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/PatientLabelFormatSuite.scala
@@ -17,8 +17,8 @@ class PatientLabelFormatSuite extends FlatSpec with Matchers {
       id = LongId(1),
       patientId = UuidId("748b5884-3528-4cb9-904b-7a8151d6e343"),
       labelId = LongId(20),
-      primaryValue = Some(LabelValue.Yes),
-      verifiedPrimaryValue = None,
+      primaryValue = LabelValue.Yes,
+      verifiedPrimaryValue = LabelValue.Unknown,
       isVisible = true,
       score = 1,
       isImplicitMatch = false
@@ -26,11 +26,11 @@ class PatientLabelFormatSuite extends FlatSpec with Matchers {
     val writtenJson = richPatientLabelFormat.write(RichPatientLabel(orig, isVerified = true))
 
     writtenJson should be(
-      """{"id":1,"labelId":20,"primaryValue":"Yes","isVisible":true,"isVerified":true,
+      """{"id":1,"labelId":20,"primaryValue":"Yes","isVisible":true,"isVerified":true,"verifiedPrimaryValue":"Unknown",
         "score":1,"isImplicitMatch":false, "patientId":"748b5884-3528-4cb9-904b-7a8151d6e343"}""".parseJson)
 
     val updatePatientLabelJson      = """{"verifiedPrimaryValue":"No"}""".parseJson
-    val expectedUpdatedPatientLabel = orig.copy(verifiedPrimaryValue = Some(LabelValue.No))
+    val expectedUpdatedPatientLabel = orig.copy(verifiedPrimaryValue = LabelValue.No)
     val parsedUpdatePatientLabel    = applyUpdateToPatientLabel(updatePatientLabelJson, orig)
     parsedUpdatePatientLabel should be(expectedUpdatedPatientLabel)
   }
@@ -65,8 +65,8 @@ class PatientLabelFormatSuite extends FlatSpec with Matchers {
       id = LongId(1),
       patientId = UuidId("748b5884-3528-4cb9-904b-7a8151d6e343"),
       labelId = LongId(20),
-      primaryValue = Some(LabelValue.Yes),
-      verifiedPrimaryValue = Some(LabelValue.Yes),
+      primaryValue = LabelValue.Yes,
+      verifiedPrimaryValue = LabelValue.Yes,
       isVisible = true,
       score = 1,
       isImplicitMatch = false
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/TrialHistoryFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/TrialHistoryFormatSuite.scala
index c17327b..7f4f169 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/TrialHistoryFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/TrialHistoryFormatSuite.scala
@@ -17,12 +17,13 @@ class TrialHistoryFormatSuite extends FlatSpec with Matchers {
       executor = xyz.driver.core.Id("userId-001"),
       state = TrialHistory.State.Summarize,
       action = TrialHistory.Action.Start,
-      created = LocalDateTime.parse("2017-08-10T18:00:00")
+      created = LocalDateTime.parse("2017-08-10T18:00:00"),
+      comment = Option("Yolo!")
     )
     val writtenJson = trialHistoryFormat.write(trialHistory)
 
     writtenJson should be("""{"id":10,"executor":"userId-001","trialId":"NCT000001","state":"Summarize",
-        "action":"Start","created":"2017-08-10T18:00Z"}""".parseJson)
+        "action":"Start","created":"2017-08-10T18:00Z", "comment": "Yolo!"}""".parseJson)
 
     val parsedTrialHistory = trialHistoryFormat.read(writtenJson)
     parsedTrialHistory should be(trialHistory)