Merge branch 'master' into PDSUI-2336

16 files changed, 154 insertions, 41 deletions

diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/ExtractedData.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/ExtractedData.scala
index 352cf55..569375a 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/ExtractedData.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/ExtractedData.scala
@@ -17,7 +17,7 @@ final case class ExtractedData(id: LongId[ExtractedData] = LongId(0L),
 
 object ExtractedData {
 
-  final case class Meta(keyword: Meta.Keyword, evidence: Meta.Evidence)
+  final case class Meta(keyword: Option[Meta.Keyword], evidence: Option[Meta.Evidence])
 
   object Meta {
     final case class Evidence(pageRatio: Double, start: TextLayerPosition, end: TextLayerPosition)
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientCriterion.scala
index 79a19ed..7027eef 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientCriterion.scala
@@ -9,11 +9,11 @@ import xyz.driver.pdsuicommon.logging._
 object PatientCriterion {
   implicit def toPhiString(x: PatientCriterion): PhiString = {
     import x._
-    phi"PatientCriterion(id=$id, patientLabelId=$patientLabelId, trialId=${Unsafe(trialId)}, nctId=${Unsafe(nctId)}, " +
+    phi"PatientCriterion(id=$id, patientLabelId=$patientLabelId, trialId=${Unsafe(trialId)}, nctId=$nctId, " +
       phi"criterionId=$criterionId, criterionValue=${Unsafe(criterionValue)}, " +
       phi"isImplicitMatch=$criterionIsDefining), criterionIsDefining=${Unsafe(criterionIsDefining)}, " +
       phi"eligibilityStatus=${Unsafe(eligibilityStatus)}, verifiedEligibilityStatus=${Unsafe(verifiedEligibilityStatus)}, " +
-      phi"isVerified=${Unsafe(isVerified)}, lastUpdate=${Unsafe(lastUpdate)}"
+      phi"isVerified=${Unsafe(isVerified)}, lastUpdate=${Unsafe(lastUpdate)}, inclusion=${Unsafe(inclusion)}"
   }
 
   /**
@@ -52,7 +52,8 @@ final case class PatientCriterion(id: LongId[PatientCriterion],
                                   verifiedEligibilityStatus: Option[LabelValue],
                                   isVerified: Boolean,
                                   isVisible: Boolean,
-                                  lastUpdate: LocalDateTime) {
+                                  lastUpdate: LocalDateTime,
+                                  inclusion: Option[Boolean]) {
   def isIneligibleForEv: Boolean = eligibilityStatus.contains(LabelValue.No) && isVerified
 }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/export/trial/ExportTrialLabelCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/export/trial/ExportTrialLabelCriterion.scala
index 8376e34..98bd084 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/export/trial/ExportTrialLabelCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/export/trial/ExportTrialLabelCriterion.scala
@@ -11,13 +11,14 @@ final case class ExportTrialLabelCriterion(criterionId: LongId[Criterion],
                                            armIds: Set[LongId[EligibilityArm]],
                                            criteria: String,
                                            isCompound: Boolean,
-                                           isDefining: Boolean)
+                                           isDefining: Boolean,
+                                           inclusion: Option[Boolean])
 
 object ExportTrialLabelCriterion {
 
   implicit def toPhiString(x: ExportTrialLabelCriterion): PhiString = {
     import x._
     phi"TrialLabelCriterion(criterionId=$criterionId, value=$value, labelId=$labelId, " +
-      phi"criteria=${Unsafe(criteria)}, isCompound=$isCompound, isDefining=$isDefining)"
+      phi"criteria=${Unsafe(criteria)}, isCompound=$isCompound, isDefining=$isDefining), inclusion=${Unsafe(inclusion)}"
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/export.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/export.scala
index 2c7d0e0..33da392 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/export.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/export.scala
@@ -28,7 +28,8 @@ object export {
       armIds = setOf(nextLongId[EligibilityArm]),
       criteria = nextString(100),
       isCompound = nextBoolean(),
-      isDefining = nextBoolean()
+      isDefining = nextBoolean(),
+      inclusion = nextOption(nextBoolean())
     )
 
   def nextExportTrialWithLabels(): ExportTrialWithLabels =
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 86583c1..3a018fa 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/recordprocessing.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/recordprocessing.scala
@@ -245,13 +245,13 @@ object recordprocessing {
 
   def nextExtractedDataMeta(): Meta = {
     ExtractedData.Meta(
-      nextExtractedDataMetaKeyword(),
-      nextExtractedDataMetaEvidence()
+      nextOption(nextExtractedDataMetaKeyword()),
+      nextOption(nextExtractedDataMetaEvidence())
     )
   }
 
   def nextExtractedDataMetaJson(): TextJson[Meta] =
-    nextTextJson(ExtractedData.Meta(nextExtractedDataMetaKeyword(), nextExtractedDataMetaEvidence()))
+    nextTextJson(nextExtractedDataMeta())
 
   def nextExtractedData(): ExtractedData = {
     ExtractedData(
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 2a06998..94c41ff 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/treatmentmatching.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/treatmentmatching.scala
@@ -86,7 +86,8 @@ object treatmentmatching {
     verifiedEligibilityStatus = generators.nextOption(fakes.entities.labels.nextLabelValue()),
     isVerified = generators.nextBoolean(),
     isVisible = generators.nextBoolean(),
-    lastUpdate = nextLocalDateTime
+    lastUpdate = nextLocalDateTime,
+    inclusion = generators.nextOption(generators.nextBoolean())
   )
 
   def nextDraftPatientCriterion(): DraftPatientCriterion = DraftPatientCriterion(
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
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiPartialDocument.scala
@@ -0,0 +1 @@
+
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/export.scala
index 6b72cb8..d70ce6f 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/export.scala
@@ -3,6 +3,7 @@ package xyz.driver.pdsuidomain.formats.json
 import spray.json._
 import xyz.driver.entities.labels.Label
 import xyz.driver.formats.json.labels._
+import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuidomain.entities.export.patient._
 import xyz.driver.pdsuidomain.entities.export.trial.{ExportTrialArm, ExportTrialLabelCriterion, ExportTrialWithLabels}
 import xyz.driver.pdsuidomain.entities.{Criterion, EligibilityArm}
@@ -13,6 +14,14 @@ object export {
   import document._
   import record._
 
+  private def deserializationErrorFieldMessage(field: String, json: JsValue)(implicit className: String) = {
+    deserializationError(s"$className json object do not contain '$field' field: $json")
+  }
+
+  private def deserializationErrorEntityMessage(json: JsValue)(implicit className: String) = {
+    deserializationError(s"Expected Json Object as $className, but got $json")
+  }
+
   implicit val patientLabelEvidenceDocumentFormat: RootJsonFormat[ExportPatientLabelEvidenceDocument] =
     jsonFormat5(ExportPatientLabelEvidenceDocument.apply)
 
@@ -29,6 +38,8 @@ object export {
 
   implicit val trialLabelCriterionFormat: RootJsonFormat[ExportTrialLabelCriterion] =
     new RootJsonFormat[ExportTrialLabelCriterion] {
+      implicit val className: String = "ExportTrialLabelCriterion"
+
       override def write(obj: ExportTrialLabelCriterion): JsValue =
         JsObject(
           "value" -> obj.value
@@ -43,40 +54,69 @@ object export {
           "criterionText" -> obj.criteria.toJson,
           "armIds"        -> obj.armIds.toJson,
           "isCompound"    -> obj.isCompound.toJson,
-          "isDefining"    -> obj.isDefining.toJson
+          "isDefining"    -> obj.isDefining.toJson,
+          "inclusion"     -> obj.inclusion.toJson
         )
 
       override def read(json: JsValue): ExportTrialLabelCriterion = {
+        json match {
+          case JsObject(fields) =>
+            val value = fields
+              .get("value")
+              .map(_.convertTo[String])
+              .map {
+                case "Yes"     => Option(true)
+                case "No"      => Option(false)
+                case "Unknown" => Option.empty[Boolean]
+              }
+              .getOrElse(deserializationErrorFieldMessage("value", json))
 
-        val fields = Seq("value", "labelId", "criterionId", "criterionText", "armIds", "isCompound", "isDefining")
-
-        json.asJsObject.getFields(fields: _*) match {
-          case Seq(JsString(valueString),
-                   labelId,
-                   criterionId,
-                   JsString(criterionText),
-                   JsArray(armIdsVector),
-                   JsBoolean(isCompound),
-                   JsBoolean(isDefining)) =>
-            val value = valueString match {
-              case "Yes"     => Option(true)
-              case "No"      => Option(false)
-              case "Unknown" => Option.empty[Boolean]
-            }
+            val labelId = fields
+              .get("labelId")
+              .map(_.convertTo[LongId[Label]])
+              .getOrElse(deserializationErrorFieldMessage("labelId", json))
+
+            val criterionId = fields
+              .get("criterionId")
+              .map(_.convertTo[LongId[Criterion]])
+              .getOrElse(deserializationErrorFieldMessage("criterionId", json))
+
+            val criterionText = fields
+              .get("criterionText")
+              .map(_.convertTo[String])
+              .getOrElse(deserializationErrorFieldMessage("criterionText", json))
+
+            val armIds = fields
+              .get("armIds")
+              .map(_.convertTo[Set[LongId[EligibilityArm]]])
+              .getOrElse(deserializationErrorFieldMessage("armIds", json))
+
+            val isCompound = fields
+              .get("isCompound")
+              .map(_.convertTo[Boolean])
+              .getOrElse(deserializationErrorFieldMessage("isCompound", json))
+
+            val isDefining = fields
+              .get("isDefining")
+              .map(_.convertTo[Boolean])
+              .getOrElse(deserializationErrorFieldMessage("isDefining", json))
+
+            val inclusion = fields
+              .get("inclusion")
+              .flatMap(_.convertTo[Option[Boolean]])
 
             ExportTrialLabelCriterion(
-              longIdFormat[Criterion].read(criterionId),
+              criterionId,
               value,
-              longIdFormat[Label].read(labelId),
-              armIdsVector.map(longIdFormat[EligibilityArm].read).toSet,
+              labelId,
+              armIds,
               criterionText,
               isCompound,
-              isDefining
+              isDefining,
+              inclusion
             )
 
-          case _ =>
-            deserializationError(
-              s"Cannot find required fields ${fields.mkString(", ")} in ExportTrialLabelCriterion object!")
+          case _ => deserializationErrorEntityMessage(json)
         }
       }
     }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention.scala
index 5cd7527..14edd5d 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/intervention.scala
@@ -99,7 +99,8 @@ object intervention {
 
       val deliveryMethod = fields
         .get("deliveryMethod")
-        .map(_.convertTo[String])
+        .map(_.convertTo[Option[String]])
+        .getOrElse(orig.intervention.deliveryMethod)
 
       val origIntervention = orig.intervention
       val arms = fields
@@ -112,7 +113,7 @@ object intervention {
           typeId = typeId.orElse(origIntervention.typeId),
           dosage = dosage.getOrElse(origIntervention.dosage),
           isActive = isActive.getOrElse(origIntervention.isActive),
-          deliveryMethod = deliveryMethod.orElse(origIntervention.deliveryMethod)
+          deliveryMethod = deliveryMethod
         ),
         arms = arms.getOrElse(orig.arms)
       )
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
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPatientCriterion.scala
@@ -0,0 +1 @@
+
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 fc0b725..fbefd33 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientcriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patientcriterion.scala
@@ -56,7 +56,8 @@ object patientcriterion {
           "verifiedEligibilityStatus" -> obj.patientCriterion.verifiedEligibilityStatus.toJson,
           "isVerified"                -> obj.patientCriterion.isVerified.toJson,
           "isVisible"                 -> obj.patientCriterion.isVisible.toJson,
-          "lastUpdate"                -> obj.patientCriterion.lastUpdate.toJson
+          "lastUpdate"                -> obj.patientCriterion.lastUpdate.toJson,
+          "inclusion"                 -> obj.patientCriterion.inclusion.toJson
         )
       }
     }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record.scala
index 9a8dc9c..b6ed103 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record.scala
@@ -15,6 +15,7 @@ object record {
   import common._
 
   implicit val recordStatusFormat = new EnumJsonFormat[Status](
+    "PreCleaning"   -> Status.PreCleaning,
     "Unprocessed"   -> Status.Unprocessed,
     "PreOrganized"  -> Status.PreOrganized,
     "New"           -> Status.New,
@@ -93,7 +94,7 @@ object record {
 
         val endOriginalPage = fields
           .get("endOriginalPage")
-          .map(_.convertTo[Double])
+          .flatMap(_.convertTo[Option[Double]])
 
         Duplicate(
           startPage = startPage,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/HypothesisService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/HypothesisService.scala
index 52cd6c8..572edb6 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/HypothesisService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/HypothesisService.scala
@@ -2,12 +2,21 @@ package xyz.driver.pdsuidomain.services
 
 import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
 import xyz.driver.pdsuicommon.db.Sorting
+import xyz.driver.pdsuicommon.domain.UuidId
 import xyz.driver.pdsuicommon.error.DomainError
 import xyz.driver.pdsuidomain.entities.Hypothesis
 
 import scala.concurrent.Future
 
 object HypothesisService {
+  trait DefaultNotFoundError {
+    def userMessage: String = "Hypothesis not found"
+  }
+
+  trait DefaultAccessDeniedError {
+    def userMessage: String = "Access denied"
+  }
+
   sealed trait GetListReply
   object GetListReply {
     final case class EntityList(xs: Seq[Hypothesis], totalFound: Int) extends GetListReply
@@ -16,6 +25,32 @@ object HypothesisService {
       def userMessage: String = "Access denied"
     }
   }
+
+  sealed trait CreateReply
+  object CreateReply {
+    final case class Created(x: Hypothesis) extends CreateReply
+
+    type Error = CreateReply with DomainError
+
+    case object AuthorizationError
+        extends CreateReply with DefaultAccessDeniedError with DomainError.AuthorizationError
+
+    final case class CommonError(userMessage: String) extends CreateReply with DomainError
+  }
+
+  sealed trait DeleteReply
+  object DeleteReply {
+    case object Deleted extends DeleteReply
+
+    type Error = DeleteReply with DomainError
+
+    case object NotFoundError extends DeleteReply with DefaultNotFoundError with DomainError.NotFoundError
+
+    case object AuthorizationError
+        extends DeleteReply with DefaultAccessDeniedError with DomainError.AuthorizationError
+
+    final case class CommonError(userMessage: String) extends DeleteReply with DomainError
+  }
 }
 
 trait HypothesisService {
@@ -24,4 +59,8 @@ trait HypothesisService {
 
   def getAll(sorting: Option[Sorting] = None)(
           implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
+
+  def create(draftHypothesis: Hypothesis)(implicit requestContext: AuthenticatedRequestContext): Future[CreateReply]
+
+  def delete(id: UuidId[Hypothesis])(implicit requestContext: AuthenticatedRequestContext): Future[DeleteReply]
 }
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 e0efcd1..e23449c 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeTrialService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeTrialService.scala
@@ -85,7 +85,8 @@ class FakeTrialService extends TrialService {
           generators.setOf(LongId[EligibilityArm](generators.nextInt(999999).toLong)),
           generators.nextName().value,
           generators.nextBoolean(),
-          generators.nextBoolean()
+          generators.nextBoolean(),
+          generators.nextOption(generators.nextBoolean())
         ))
     )
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHelper.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHelper.scala
index bf42f40..8e75c76 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHelper.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHelper.scala
@@ -59,9 +59,9 @@ trait RestHelper {
     def exprToQuery(expr: SearchFilterExpr): Seq[(String, String)] = expr match {
       case SearchFilterExpr.Empty => Seq.empty
       case SearchFilterExpr.Atom.Binary(dimension, op, value) =>
-        Seq("filters" -> s"${dimension.name} ${opToString(op)} $value")
+        Seq("filters" -> s"${dimension.tableName.fold("")(t => s"$t.") + dimension.name} ${opToString(op)} $value")
       case SearchFilterExpr.Atom.NAry(dimension, SearchFilterNAryOperation.In, values) =>
-        Seq("filters" -> s"${dimension.name} in ${values.mkString(",")}")
+        Seq("filters" -> s"${dimension.tableName.fold("")(t => s"$t.") + dimension.name} in ${values.mkString(",")}")
       case SearchFilterExpr.Intersection(ops) =>
         ops.flatMap(op => exprToQuery(op))
       case expr => sys.error(s"No parser available for filter expression $expr.")
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHypothesisService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHypothesisService.scala
index a352053..73abb0e 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHypothesisService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHypothesisService.scala
@@ -1,11 +1,14 @@
 package xyz.driver.pdsuidomain.services.rest
 
+import akka.http.scaladsl.marshalling.Marshal
+
 import scala.concurrent.{ExecutionContext, Future}
 import akka.http.scaladsl.model._
 import akka.stream.Materializer
 import xyz.driver.core.rest._
 import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
+import xyz.driver.pdsuicommon.domain.UuidId
 import xyz.driver.pdsuidomain.ListResponse
 import xyz.driver.pdsuidomain.entities.Hypothesis
 import xyz.driver.pdsuidomain.services.HypothesisService
@@ -31,4 +34,25 @@ class RestHypothesisService(transport: ServiceTransport, baseUri: Uri)(
     }
   }
 
+  def create(draftHypothesis: Hypothesis)(implicit requestContext: AuthenticatedRequestContext): Future[CreateReply] = {
+    for {
+      entity <- Marshal(draftHypothesis).to[RequestEntity]
+      request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, "/v1/hypothesis")).withEntity(entity)
+      response <- transport.sendRequestGetResponse(requestContext)(request)
+      reply    <- apiResponse[Hypothesis](response)
+    } yield {
+      CreateReply.Created(reply)
+    }
+  }
+
+  def delete(id: UuidId[Hypothesis])(implicit requestContext: AuthenticatedRequestContext): Future[DeleteReply] = {
+    val request = HttpRequest(HttpMethods.DELETE, endpointUri(baseUri, s"/v1/hypothesis/$id"))
+    for {
+      response <- transport.sendRequestGetResponse(requestContext)(request)
+      _        <- apiResponse[HttpEntity](response)
+    } yield {
+      DeleteReply.Deleted
+    }
+  }
+
 }