Merge pull request #35 from drivergroup/trial-46-disease-entity

Trial 46 disease entity

11 files changed, 131 insertions, 57 deletions

diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/EligibilityArmService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/EligibilityArmService.scala
index b34b34e..1e0f65e 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/EligibilityArmService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/EligibilityArmService.scala
@@ -5,7 +5,7 @@ import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuicommon.error.DomainError
 import xyz.driver.pdsuicommon.logging._
-import xyz.driver.pdsuidomain.entities.EligibilityArm
+import xyz.driver.pdsuidomain.entities.{EligibilityArm, EligibilityArmWithDiseases, SlotArm}
 
 import scala.concurrent.Future
 
@@ -19,10 +19,14 @@ object EligibilityArmService {
     def userMessage: String = "EligibilityArm not found"
   }
 
+  trait SlotArmNotFoundError {
+    def userMessage: String = "SlotArm not found"
+  }
+
   sealed trait GetByIdReply
   object GetByIdReply {
 
-    final case class Entity(x: EligibilityArm) extends GetByIdReply
+    final case class Entity(x: EligibilityArmWithDiseases) extends GetByIdReply
 
     type Error = GetByIdReply with DomainError
 
@@ -39,7 +43,7 @@ object EligibilityArmService {
   object GetListReply {
     type Error = GetListReply with DomainError
 
-    final case class EntityList(xs: Seq[EligibilityArm], totalFound: Int) extends GetListReply
+    final case class EntityList(xs: Seq[EligibilityArmWithDiseases], totalFound: Int) extends GetListReply
 
     case object AuthorizationError
         extends GetListReply with DomainError.AuthorizationError with DefaultAccessDeniedError
@@ -48,7 +52,7 @@ object EligibilityArmService {
   sealed trait UpdateReply
   object UpdateReply {
 
-    final case class Updated(updated: EligibilityArm) extends UpdateReply
+    final case class Updated(updated: EligibilityArmWithDiseases) extends UpdateReply
 
     type Error = UpdateReply with DomainError
 
@@ -59,7 +63,7 @@ object EligibilityArmService {
 
     final case class CommonError(userMessage: String) extends UpdateReply with DomainError
 
-    final case class AlreadyExistsError(x: EligibilityArm) extends UpdateReply with DomainError {
+    final case class AlreadyExistsError(x: EligibilityArmWithDiseases) extends UpdateReply with DomainError {
       val userMessage = s"The arm with such name of trial already exists."
     }
 
@@ -71,16 +75,18 @@ object EligibilityArmService {
 
   sealed trait CreateReply
   object CreateReply {
-    final case class Created(x: EligibilityArm) extends CreateReply
+    final case class Created(x: EligibilityArmWithDiseases) extends CreateReply
 
     type Error = CreateReply with DomainError
 
     case object AuthorizationError
         extends CreateReply with DefaultAccessDeniedError with DomainError.AuthorizationError
 
+    case object NotFoundError extends CreateReply with SlotArmNotFoundError with DomainError.NotFoundError
+
     final case class CommonError(userMessage: String) extends CreateReply with DomainError
 
-    final case class AlreadyExistsError(x: EligibilityArm) extends CreateReply with DomainError {
+    final case class AlreadyExistsError(x: EligibilityArmWithDiseases) extends CreateReply with DomainError {
       val userMessage = s"The arm with this name of trial already exists."
     }
 
@@ -114,13 +120,19 @@ trait EligibilityArmService {
              pagination: Option[Pagination] = None)(
           implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
 
-  def getById(armId: LongId[EligibilityArm])(
+  def getByEligibilityId(armId: LongId[EligibilityArm])(
           implicit requestContext: AuthenticatedRequestContext): Future[GetByIdReply]
 
-  def create(draftEligibilityArm: EligibilityArm)(
+  def getBySlotId(armId: LongId[SlotArm],
+                  filter: SearchFilterExpr = SearchFilterExpr.Empty,
+                  sorting: Option[Sorting] = None,
+                  pagination: Option[Pagination] = None)(
+          implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
+
+  def create(slotArmId: LongId[SlotArm], draftEligibilityArm: EligibilityArmWithDiseases)(
           implicit requestContext: AuthenticatedRequestContext): Future[CreateReply]
 
-  def update(origEligibilityArm: EligibilityArm, draftEligibilityArm: EligibilityArm)(
+  def update(origEligibilityArm: EligibilityArmWithDiseases, draftEligibilityArm: EligibilityArmWithDiseases)(
           implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply]
 
   def delete(id: LongId[EligibilityArm])(implicit requestContext: AuthenticatedRequestContext): Future[DeleteReply]
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/EligibilityVerificationService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/EligibilityVerificationService.scala
index 7395400..c09dd9a 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/EligibilityVerificationService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/EligibilityVerificationService.scala
@@ -4,6 +4,7 @@ import xyz.driver.core.Id
 import xyz.driver.core.rest.AuthorizedServiceRequestContext
 import xyz.driver.entities.patient.{CancerType, Patient}
 import xyz.driver.entities.users.AuthUserInfo
+import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuidomain.entities.eligibility.{MatchedPatient, MismatchRankedLabels}
 import xyz.driver.pdsuidomain.entities.Arm
 
@@ -14,6 +15,6 @@ trait EligibilityVerificationService {
 
   def getMatchedPatients()(implicit ctx: AuthorizedServiceRequestContext[AuthUserInfo]): ListT[Future, MatchedPatient]
 
-  def getMismatchRankedLabels(patientId: Id[Patient], cancerType: CancerType, excludedArms: Seq[Id[Arm]])(
+  def getMismatchRankedLabels(patientId: Id[Patient], cancerType: CancerType, excludedArms: Seq[LongId[Arm]])(
           implicit ctx: AuthorizedServiceRequestContext[AuthUserInfo]): Future[MismatchRankedLabels]
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/PatientCriterionService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/PatientCriterionService.scala
index 6d85f85..4d0e188 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/PatientCriterionService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/PatientCriterionService.scala
@@ -2,7 +2,7 @@ package xyz.driver.pdsuidomain.services
 
 import java.time.LocalDateTime
 
-import xyz.driver.entities.labels.Label
+import xyz.driver.entities.labels.{Label, LabelValue}
 import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain._
@@ -15,7 +15,7 @@ import scala.concurrent.Future
 object PatientCriterionService {
 
   final case class DraftPatientCriterion(id: LongId[PatientCriterion],
-                                         eligibilityStatus: Option[FuzzyValue],
+                                         eligibilityStatus: Option[LabelValue],
                                          isVerified: Option[Boolean]) {
     def applyTo(orig: PatientCriterion) = {
       orig.copy(
@@ -37,13 +37,21 @@ object PatientCriterionService {
     def userMessage: String = "Access denied"
   }
 
+  final case class RichPatientCriterion(patientCriterion: PatientCriterion,
+                                        labelId: LongId[Label],
+                                        armList: List[PatientCriterionArm])
+
+  object RichPatientCriterion {
+    implicit def toPhiString(x: RichPatientCriterion): PhiString = {
+      phi"RichPatientCriterion(patientCriterion=${x.patientCriterion}, labelId=${x.labelId}, arms=${x.armList})"
+    }
+  }
+
   sealed trait GetListReply
   object GetListReply {
     type Error = GetListReply with DomainError
 
-    final case class EntityList(xs: Seq[(PatientCriterion, LongId[Label], List[PatientCriterionArm])],
-                                totalFound: Int,
-                                lastUpdate: Option[LocalDateTime])
+    final case class EntityList(xs: Seq[RichPatientCriterion], totalFound: Int, lastUpdate: Option[LocalDateTime])
         extends GetListReply
 
     case object AuthorizationError
@@ -60,8 +68,7 @@ object PatientCriterionService {
   object GetByIdReply {
     type Error = GetByIdReply with DomainError
 
-    final case class Entity(x: PatientCriterion, labelId: LongId[Label], armList: List[PatientCriterionArm])
-        extends GetByIdReply
+    final case class Entity(x: RichPatientCriterion) extends GetByIdReply
 
     case object AuthorizationError
         extends GetByIdReply with DomainError.AuthorizationError with DefaultAccessDeniedError
@@ -74,8 +81,8 @@ object PatientCriterionService {
     final case class CommonError(userMessage: String) extends GetByIdReply with DomainError
 
     implicit def toPhiString(reply: GetByIdReply): PhiString = reply match {
-      case x: DomainError              => phi"GetByIdReply.Error($x)"
-      case Entity(x, labelId, armList) => phi"GetByIdReply.Entity(entity=$x, labelId=$labelId, armList=$armList)"
+      case x: DomainError => phi"GetByIdReply.Error($x)"
+      case Entity(x)      => phi"GetByIdReply.Entity($x)"
     }
   }
 
@@ -83,8 +90,7 @@ object PatientCriterionService {
   object UpdateReply {
     type Error = UpdateReply with DomainError
 
-    final case class Updated(x: PatientCriterion, labelId: LongId[Label], armList: List[PatientCriterionArm])
-        extends UpdateReply
+    final case class Updated(x: RichPatientCriterion) extends UpdateReply
 
     case object UpdatedList extends UpdateReply
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/PatientEligibleTrialService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/PatientEligibleTrialService.scala
index abb3f8a..d9013c6 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/PatientEligibleTrialService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/PatientEligibleTrialService.scala
@@ -1,12 +1,12 @@
 package xyz.driver.pdsuidomain.services
 
-import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
 import xyz.driver.pdsuicommon.db.{Pagination, SearchFilterExpr, Sorting}
 import xyz.driver.pdsuicommon.domain.{LongId, UuidId}
 import xyz.driver.pdsuicommon.error.DomainError
 import xyz.driver.pdsuicommon.logging._
 import xyz.driver.pdsuidomain.entities.{Trial, _}
+import xyz.driver.pdsuidomain.services.PatientCriterionService.RichPatientCriterion
 
 import scala.concurrent.Future
 
@@ -71,8 +71,7 @@ object PatientEligibleTrialService {
 
   sealed trait GetCriterionListOfGroupReply
   object GetCriterionListOfGroupReply {
-    final case class EntityList(xs: Seq[(PatientCriterion, LongId[Label], List[PatientCriterionArm])], totalFound: Int)
-        extends GetCriterionListOfGroupReply
+    final case class EntityList(xs: Seq[RichPatientCriterion], totalFound: Int) extends GetCriterionListOfGroupReply
 
     type Error = GetCriterionListOfGroupReply with DomainError
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/PatientHypothesisService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/PatientHypothesisService.scala
index f782cab..07734ed 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/PatientHypothesisService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/PatientHypothesisService.scala
@@ -23,9 +23,17 @@ object PatientHypothesisService {
     def userMessage: String = "Access denied"
   }
 
+  final case class RichPatientHypothesis(patientHypothesis: PatientHypothesis, isRequired: Boolean)
+
+  object RichPatientHypothesis {
+    implicit def toPhiString(x: RichPatientHypothesis): PhiString = {
+      phi"RichPatientHypothesis(patientHypothesis=${x.patientHypothesis}, isRequired=${x.isRequired})"
+    }
+  }
+
   sealed trait GetListReply
   object GetListReply {
-    final case class EntityList(xs: Seq[(PatientHypothesis, Boolean)], totalFound: Int) extends GetListReply
+    final case class EntityList(xs: Seq[RichPatientHypothesis], totalFound: Int) extends GetListReply
 
     case object AuthorizationError
         extends GetListReply with DomainError.AuthorizationError with DefaultAccessDeniedError
@@ -38,7 +46,7 @@ object PatientHypothesisService {
 
   sealed trait GetByIdReply
   object GetByIdReply {
-    final case class Entity(x: PatientHypothesis, isRequired: Boolean) extends GetByIdReply
+    final case class Entity(x: RichPatientHypothesis) extends GetByIdReply
 
     type Error = GetByIdReply with DomainError
 
@@ -53,8 +61,8 @@ object PatientHypothesisService {
     final case class CommonError(userMessage: String) extends GetByIdReply with DomainError
 
     implicit def toPhiString(reply: GetByIdReply): PhiString = reply match {
-      case x: DomainError        => phi"GetByIdReply.Error($x)"
-      case Entity(x, isRequired) => phi"GetByIdReply.Entity($x, $isRequired)"
+      case x: DomainError => phi"GetByIdReply.Error($x)"
+      case Entity(x)      => phi"GetByIdReply.Entity($x)"
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/PatientLabelService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/PatientLabelService.scala
index 2a4d7fc..cede890 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/PatientLabelService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/PatientLabelService.scala
@@ -24,9 +24,17 @@ object PatientLabelService {
     def userMessage: String = "Access denied"
   }
 
+  final case class RichPatientLabel(patientLabel: PatientLabel, isVerified: Boolean)
+
+  object RichPatientLabel {
+    implicit def toPhiString(x: RichPatientLabel): PhiString = {
+      phi"RichPatientLabel(patientLabel=${x.patientLabel}, isVerified=${x.isVerified})"
+    }
+  }
+
   sealed trait GetListReply
   object GetListReply {
-    final case class EntityList(xs: Seq[(PatientLabel, Boolean)], totalFound: Int) extends GetListReply
+    final case class EntityList(xs: Seq[RichPatientLabel], totalFound: Int) extends GetListReply
 
     case object AuthorizationError
         extends GetListReply with DomainError.AuthorizationError with DefaultAccessDeniedError
@@ -52,7 +60,7 @@ object PatientLabelService {
 
   sealed trait GetByLabelIdReply
   object GetByLabelIdReply {
-    final case class Entity(x: PatientLabel, isVerified: Boolean) extends GetByLabelIdReply
+    final case class Entity(x: RichPatientLabel) extends GetByLabelIdReply
 
     type Error = GetByLabelIdReply with DomainError
 
@@ -68,7 +76,7 @@ object PatientLabelService {
 
     implicit def toPhiString(reply: GetByLabelIdReply): PhiString = reply match {
       case x: DomainError => phi"GetByIdReply.Error($x)"
-      case Entity(x, y)   => phi"GetByIdReply.Entity($x, $y)"
+      case Entity(x)      => phi"GetByIdReply.Entity($x)"
     }
   }
 
@@ -76,7 +84,7 @@ object PatientLabelService {
   object UpdateReply {
     type Error = UpdateReply with DomainError
 
-    final case class Updated(updated: PatientLabel, isVerified: Boolean) extends UpdateReply
+    final case class Updated(updated: RichPatientLabel) extends UpdateReply
 
     case object NotFoundError extends UpdateReply with DefaultNotFoundError with DomainError.NotFoundError
 
@@ -89,8 +97,8 @@ object PatientLabelService {
     final case class CommonError(userMessage: String) extends UpdateReply with DomainError
 
     implicit def toPhiString(reply: UpdateReply): PhiString = reply match {
-      case Updated(x, y) => phi"Updated($x, $y)"
-      case x: Error      => DomainError.toPhiString(x)
+      case Updated(x) => phi"Updated($x)"
+      case x: Error   => DomainError.toPhiString(x)
     }
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/TrialService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/TrialService.scala
index 5bd99a8..92233e4 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/TrialService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/TrialService.scala
@@ -5,6 +5,7 @@ import java.time.LocalDateTime
 import akka.NotUsed
 import akka.stream.scaladsl.Source
 import akka.util.ByteString
+import xyz.driver.entities.patient.CancerType
 import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain.StringId
@@ -68,6 +69,20 @@ object TrialService {
         extends GetTrialWithLabelsReply with DomainError.AuthorizationError with DefaultAccessDeniedError
   }
 
+  sealed trait GetTrialsWithLabelsReply
+  object GetTrialsWithLabelsReply {
+    type Error = GetTrialsWithLabelsReply with DomainError
+
+    final case class EntityList(xs: Seq[ExportTrialWithLabels]) extends GetTrialsWithLabelsReply
+
+    case object NotFoundError extends GetTrialsWithLabelsReply with DomainError.NotFoundError {
+      def userMessage: String = "Trials for disease are not found"
+    }
+
+    case object AuthorizationError
+        extends GetTrialsWithLabelsReply with DomainError.AuthorizationError with DefaultAccessDeniedError
+  }
+
   sealed trait UpdateReply
   object UpdateReply {
     type Error = UpdateReply with DomainError
@@ -94,9 +109,12 @@ trait TrialService {
 
   def getById(id: StringId[Trial])(implicit requestContext: AuthenticatedRequestContext): Future[GetByIdReply]
 
-  def getTrialWithLabels(trialId: StringId[Trial], condition: String)(
+  def getTrialWithLabels(trialId: StringId[Trial], cancerType: CancerType)(
           implicit requestContext: AuthenticatedRequestContext): Future[GetTrialWithLabelsReply]
 
+  def getTrialsWithLabels(cancerType: CancerType)(
+          implicit requestContext: AuthenticatedRequestContext): Future[GetTrialsWithLabelsReply]
+
   def getPdfSource(trialId: StringId[Trial])(
           implicit requestContext: AuthenticatedRequestContext): Future[Source[ByteString, NotUsed]]
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeEligibilityVerificationService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeEligibilityVerificationService.scala
index 1e1a3ea..c9b5443 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeEligibilityVerificationService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeEligibilityVerificationService.scala
@@ -5,6 +5,7 @@ import xyz.driver.core.{Id, generators}
 import xyz.driver.entities.patient
 import xyz.driver.entities.patient.Patient
 import xyz.driver.entities.users.AuthUserInfo
+import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuidomain.entities.eligibility.MismatchRankedLabels
 import xyz.driver.pdsuidomain.entities.{Arm, eligibility}
 import xyz.driver.pdsuidomain.services.EligibilityVerificationService
@@ -21,7 +22,7 @@ class FakeEligibilityVerificationService extends EligibilityVerificationService
 
   override def getMismatchRankedLabels(patientId: Id[Patient],
                                        cancerType: patient.CancerType,
-                                       excludedArms: Seq[Id[Arm]])(
+                                       excludedArms: Seq[LongId[Arm]])(
           implicit ctx: AuthorizedServiceRequestContext[AuthUserInfo]): Future[eligibility.MismatchRankedLabels] =
     Future.successful(
       MismatchRankedLabels(
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 9253f88..0431d95 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeTrialService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeTrialService.scala
@@ -7,11 +7,12 @@ import akka.stream.scaladsl.Source
 import akka.util.ByteString
 import xyz.driver.core.generators
 import xyz.driver.entities.labels.Label
+import xyz.driver.entities.patient.CancerType
 import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId}
-import xyz.driver.pdsuidomain.entities.{Arm, Criterion, Trial}
 import xyz.driver.pdsuidomain.entities.export.trial.{ExportTrialArm, ExportTrialLabelCriterion, ExportTrialWithLabels}
+import xyz.driver.pdsuidomain.entities.{Criterion, EligibilityArm, Trial}
 import xyz.driver.pdsuidomain.services.TrialService
 
 import scala.concurrent.Future
@@ -56,30 +57,36 @@ class FakeTrialService extends TrialService {
           implicit requestContext: AuthenticatedRequestContext): Future[GetListReply] =
     Future.successful(GetListReply.EntityList(Seq(trial), 1, None))
 
-  override def getTrialWithLabels(trialId: StringId[Trial], condition: String)(
-          implicit requestContext: AuthenticatedRequestContext): Future[GetTrialWithLabelsReply] = {
-    Future.successful(
-      GetTrialWithLabelsReply.Entity(ExportTrialWithLabels(
-        StringId[Trial]("NCT" + generators.nextInt(999999).toString),
-        UuidId[Trial](generators.nextUuid()),
-        generators.oneOf("adenocarcinoma", "breast", "prostate"),
-        LocalDateTime.now(),
-        labelVersion = 1L,
-        generators.listOf(new ExportTrialArm(
-          LongId[Arm](generators.nextInt(999999).toLong),
+  override def getTrialWithLabels(trialId: StringId[Trial], cancerType: CancerType)(
+          implicit requestContext: AuthenticatedRequestContext): Future[GetTrialWithLabelsReply] =
+    Future.successful(GetTrialWithLabelsReply.Entity(nextExportTrialWithLabels()))
+
+  override def getTrialsWithLabels(cancerType: CancerType)(
+          implicit requestContext: AuthenticatedRequestContext): Future[GetTrialsWithLabelsReply] =
+    Future.successful(GetTrialsWithLabelsReply.EntityList(generators.seqOf(nextExportTrialWithLabels())))
+
+  private def nextExportTrialWithLabels() =
+    ExportTrialWithLabels(
+      StringId[Trial]("NCT" + generators.nextInt(999999).toString),
+      UuidId[Trial](generators.nextUuid()),
+      LocalDateTime.now(),
+      labelVersion = 1L,
+      generators.listOf(
+        new ExportTrialArm(
+          LongId[EligibilityArm](generators.nextInt(999999).toLong),
           generators.nextName().value
         )),
-        generators.listOf(new ExportTrialLabelCriterion(
+      generators.listOf(
+        new ExportTrialLabelCriterion(
           LongId[Criterion](generators.nextInt(999999).toLong),
           generators.nextOption(generators.nextBoolean()),
           LongId[Label](generators.nextInt(999999).toLong),
-          generators.setOf(LongId[Arm](generators.nextInt(999999).toLong)),
+          generators.setOf(LongId[EligibilityArm](generators.nextInt(999999).toLong)),
           generators.nextName().value,
           generators.nextBoolean(),
           generators.nextBoolean()
         ))
-      )))
-  }
+    )
 
   def update(origTrial: Trial, draftTrial: Trial)(
           implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply] =
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestEligibilityVerificationService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestEligibilityVerificationService.scala
index f6879d0..8869106 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestEligibilityVerificationService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestEligibilityVerificationService.scala
@@ -8,6 +8,7 @@ import xyz.driver.core.rest.{AuthorizedServiceRequestContext, RestService, Servi
 import xyz.driver.entities.patient
 import xyz.driver.entities.patient.Patient
 import xyz.driver.entities.users.AuthUserInfo
+import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuidomain.entities.eligibility.{MatchedPatient, MismatchRankedLabels}
 import xyz.driver.pdsuidomain.entities.{Arm, eligibility}
 import xyz.driver.pdsuidomain.services.EligibilityVerificationService
@@ -33,11 +34,11 @@ class RestEligibilityVerificationService(transport: ServiceTransport, baseUri: U
 
   override def getMismatchRankedLabels(patientId: Id[Patient],
                                        cancerType: patient.CancerType,
-                                       excludedArms: Seq[Id[Arm]])(
+                                       excludedArms: Seq[LongId[Arm]])(
           implicit ctx: AuthorizedServiceRequestContext[AuthUserInfo]): Future[eligibility.MismatchRankedLabels] = {
 
     val query =
-      Seq("disease" -> cancerType.toString.toUpperCase, "ineligible_arms" -> excludedArms.map(_.value).mkString(","))
+      Seq("disease" -> cancerType.toString.toUpperCase, "ineligible_arms" -> excludedArms.map(_.id).mkString(","))
 
     val request = get(baseUri, s"/v1/patients/$patientId/labels", query)
     optionalResponse[MismatchRankedLabels](transport.sendRequest(ctx)(request))
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 7e33919..ea719e1 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala
@@ -16,7 +16,9 @@ import xyz.driver.pdsuidomain.entities.export.trial.ExportTrialWithLabels
 import xyz.driver.pdsuidomain.formats.json.ListResponse
 import xyz.driver.pdsuidomain.formats.json.trial.ApiTrial
 import xyz.driver.pdsuidomain.services.TrialService
+import spray.json.DefaultJsonProtocol._
 import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+import xyz.driver.entities.patient.CancerType
 import xyz.driver.pdsuidomain.formats.json.sprayformats.export._
 
 class RestTrialService(transport: ServiceTransport, baseUri: Uri)(implicit protected val materializer: Materializer,
@@ -36,9 +38,9 @@ class RestTrialService(transport: ServiceTransport, baseUri: Uri)(implicit prote
     }
   }
 
-  def getTrialWithLabels(trialId: StringId[Trial], disease: String)(
+  def getTrialWithLabels(trialId: StringId[Trial], cancerType: CancerType)(
           implicit requestContext: AuthenticatedRequestContext): Future[GetTrialWithLabelsReply] = {
-    val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/export/trial/$disease/$trialId"))
+    val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/export/trial/$cancerType/$trialId"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
       reply    <- apiResponse[ExportTrialWithLabels](response)
@@ -47,6 +49,17 @@ class RestTrialService(transport: ServiceTransport, baseUri: Uri)(implicit prote
     }
   }
 
+  def getTrialsWithLabels(cancerType: CancerType)(
+          implicit requestContext: AuthenticatedRequestContext): Future[GetTrialsWithLabelsReply] = {
+    val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/export/trial/$cancerType"))
+    for {
+      response <- transport.sendRequestGetResponse(requestContext)(request)
+      reply    <- apiResponse[Seq[ExportTrialWithLabels]](response)
+    } yield {
+      GetTrialsWithLabelsReply.EntityList(reply)
+    }
+  }
+
   def getPdfSource(trialId: StringId[Trial])(
           implicit requestContext: AuthenticatedRequestContext): Future[Source[ByteString, NotUsed]] = {
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/trial/$trialId/source"))