aboutsummaryrefslogtreecommitdiff
path: root/src/main/scala/xyz/driver/pdsuidomain/entities/ScrapedTrial.scala
blob: e7ee1cb47fd76972c12ddec2f15956685c304eea (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
package xyz.driver.pdsuidomain.entities

import java.time.LocalDateTime
import java.util.UUID

import xyz.driver.pdsuicommon.logging._
import xyz.driver.pdsuicommon.domain.UuidId

final case class ScrapedStudyDesign(value: String)

final case class ScrapedOverall(affiliation: String,
                                status: String,
                                facilityName: Option[String],
                                firstName: Option[String],
                                lastName: Option[String],
                                phone: Option[String],
                                phoneExt: Option[String],
                                email: Option[String],
                                isBackup: Boolean)

final case class ScrapedInterventionType(value: String)

final case class ScrapedIntervention(name: String,
                                     kind: ScrapedInterventionType,
                                     description: Option[String],
                                     isSynonym: Boolean)

object ScrapedIntervention {

  implicit def toPhiString(x: ScrapedIntervention): PhiString =
    phi"ScrapedIntervention(${Unsafe(x.name)})"
}

final case class ScrapedArm(name: String, kind: Option[String], interventions: Set[ScrapedIntervention])

object ScrapedArm {

  implicit def toPhiString(x: ScrapedArm): PhiString = {
    import x._
    phi"ScrapedArm(name=${Unsafe(name)}, inverventions=$interventions)"
  }
}

final case class ScrapedTrialChecksum(eligibilityCriteria: String,
                                      briefSummary: String,
                                      detailedDescription: String,
                                      armDescription: String)

object ScrapedTrialChecksum {

  implicit def toPhiString(x: ScrapedTrialChecksum): PhiString = {
    import x._
    phi"ScrapedTrialChecksum(eligibilityCriteria=${Unsafe(eligibilityCriteria)}, briefSummary=${Unsafe(briefSummary)}, " +
      phi"detailedDescription=${Unsafe(detailedDescription)}, armDescription=${Unsafe(armDescription)}"
  }
}

object ScrapedTrial {

  implicit def toPhiString(x: ScrapedTrial): PhiString = {
    import x._
    phi"ScrapedTrial(rawId=$rawId, nctId=${Unsafe(nctId)}, arms=$arms, checksum=$checksum)"
  }
}

final case class ScrapedTrial(rawId: UuidId[ScrapedTrial],
                              createdAt: LocalDateTime,
                              disease: String,
                              nctId: String,
                              nctUuid: UUID,
                              title: Option[String],
                              startDate: Option[LocalDateTime],
                              phase: String,
                              studyDesign: Option[ScrapedStudyDesign],
                              overall: Set[ScrapedOverall],
                              // // see ClinicalTrialRaw
                              // trialHtml: String,
                              // eligibilityText: String,
                              lastReviewed: LocalDateTime,
                              arms: Set[ScrapedArm],
                              checksum: ScrapedTrialChecksum)