From a0877d81ca2844d75dc361b5ce7c99afacd6e25f Mon Sep 17 00:00:00 2001
From: vlad <vlad@driver.xyz>
Date: Thu, 25 Jan 2018 14:12:31 -0800
Subject: Extracting query library

---
 .../driver/pdsuidomain/entities/UserHistory.scala  | 146 ---------------------
 1 file changed, 146 deletions(-)
 delete mode 100644 src/main/scala/xyz/driver/pdsuidomain/entities/UserHistory.scala

(limited to 'src/main/scala/xyz/driver/pdsuidomain/entities/UserHistory.scala')

diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/UserHistory.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/UserHistory.scala
deleted file mode 100644
index 6299ed4..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/UserHistory.scala
+++ /dev/null
@@ -1,146 +0,0 @@
-package xyz.driver.pdsuidomain.entities
-
-import java.time.{LocalDateTime, ZoneId}
-
-import xyz.driver.core.auth.User
-import xyz.driver.pdsuicommon.domain._
-import xyz.driver.pdsuicommon.logging._
-import xyz.driver.pdsuicommon.utils.Utils
-
-final case class UserHistory(id: LongId[UserHistory],
-                             executor: xyz.driver.core.Id[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: xyz.driver.core.Id[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: xyz.driver.core.Id[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: xyz.driver.core.Id[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=${Unsafe(executor)}, recordId=$recordId, " +
-      phi"documentId=$documentId, trialId=$trialId, patientId=$patientId, " +
-      phi"state=$state, action=$action, created=$created)"
-  }
-}
-- 
cgit v1.2.3