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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
package xyz.driver.pdsuidomain.entities
import java.time.{LocalDateTime, ZoneId}
import xyz.driver.pdsuicommon.domain._
import xyz.driver.pdsuicommon.logging._
import xyz.driver.pdsuicommon.utils.Utils
final case class UserHistory(id: LongId[UserHistory],
executor: StringId[User],
recordId: Option[LongId[MedicalRecord]] = None,
documentId: Option[LongId[Document]] = None,
trialId: Option[StringId[Trial]] = None,
patientId: Option[UuidId[Patient]] = None,
state: UserHistory.State,
action: UserHistory.Action,
created: LocalDateTime = LocalDateTime.now(ZoneId.of("Z")))
object UserHistory {
def forDocument(executor: StringId[User],
documentId: LongId[Document],
state: UserHistory.State,
action: UserHistory.Action): UserHistory = UserHistory(
id = LongId(0L),
executor = executor,
documentId = Some(documentId),
state = state,
action = action
)
def forRecord(executor: StringId[User],
recordId: LongId[MedicalRecord],
state: UserHistory.State,
action: UserHistory.Action): UserHistory = UserHistory(
id = LongId(0L),
executor = executor,
recordId = Some(recordId),
state = state,
action = action
)
def forPatient(executor: StringId[User],
patientId: UuidId[Patient],
state: UserHistory.State,
action: UserHistory.Action): UserHistory = UserHistory(
id = LongId(0L),
executor = executor,
patientId = Some(patientId),
state = state,
action = action
)
sealed trait State extends Product with Serializable {
def oneOf(xs: State*): Boolean = xs.contains(this)
def oneOf(xs: Set[State]): Boolean = xs.contains(this)
}
object State {
case object Clean extends State
case object Organize extends State
case object Extract extends State
case object Summarize extends State
case object Criteriarize extends State
case object Verify extends State
case object Curate extends State
case object Review extends State
case object Flag extends State
val All: Set[State] = Set[State](Clean, Organize, Extract, Summarize, Criteriarize, Verify, Curate, Review, Flag)
val fromString: PartialFunction[String, State] = {
case "Clean" => State.Clean
case "Organize" => State.Organize
case "Extract" => State.Extract
case "Summarize" => State.Summarize
case "Criteriarize" => State.Criteriarize
case "Verify" => State.Verify
case "Curate" => State.Curate
case "Review" => State.Review
case "Flag" => State.Flag
}
def stateToString(x: State): String = x match {
case State.Clean => "Clean"
case State.Organize => "Organize"
case State.Extract => "Extract"
case State.Summarize => "Summarize"
case State.Criteriarize => "Criteriarize"
case State.Verify => "Verify"
case State.Curate => "Curate"
case State.Review => "Review"
case State.Flag => "Flag"
}
implicit def toPhiString(x: State): PhiString = Unsafe(Utils.getClassSimpleName(x.getClass))
}
sealed trait Action extends Product with Serializable {
def oneOf(xs: Action*): Boolean = xs.contains(this)
def oneOf(xs: Set[Action]): Boolean = xs.contains(this)
}
object Action {
case object Start extends Action
case object Submit extends Action
case object Unassign extends Action
case object Resolve extends Action
case object Flag extends Action
case object Archive extends Action
val All: Set[Action] = Set[Action](Start, Submit, Unassign, Resolve, Flag, Archive)
val fromString: PartialFunction[String, Action] = {
case "Start" => Action.Start
case "Submit" => Action.Submit
case "Unassign" => Action.Unassign
case "Resolve" => Action.Resolve
case "Flag" => Action.Flag
case "Archive" => Action.Archive
}
def actionToString(x: Action): String = x match {
case Action.Start => "Start"
case Action.Submit => "Submit"
case Action.Unassign => "Unassign"
case Action.Resolve => "Resolve"
case Action.Flag => "Flag"
case Action.Archive => "Archive"
}
implicit def toPhiString(x: Action): PhiString = Unsafe(Utils.getClassSimpleName(x.getClass))
}
implicit def toPhiString(x: UserHistory): PhiString = {
import x._
phi"UserHistory(id=$id, executor=$executor, recordId=$recordId, " +
phi"documentId=$documentId, trialId=$trialId, patientId=$patientId, " +
phi"state=$state, action=$action, created=$created)"
}
}
|
