All PDS UI domain models, API case classes, service traits and necessary utils moved to pdsui-commonv0.1.11

4 files changed, 175 insertions, 0 deletions

diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiCreateRecord.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiCreateRecord.scala
new file mode 100644
index 0000000..57c030b
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiCreateRecord.scala
@@ -0,0 +1,37 @@
+package xyz.driver.pdsuidomain.formats.json.record
+
+import java.time.LocalDateTime
+import java.util.UUID
+
+import xyz.driver.pdsuicommon.domain._
+import xyz.driver.pdsuidomain.entities._
+import play.api.libs.json._
+
+final case class ApiCreateRecord(disease: String,
+                                 patientId: String,
+                                 requestId: UUID,
+                                 filename: String) {
+
+  def toDomain = MedicalRecord(
+    id = LongId(0),
+    status = MedicalRecord.Status.New,
+    previousStatus = None,
+    assignee = None,
+    previousAssignee = None,
+    patientId = UuidId(patientId),
+    requestId = RecordRequestId(requestId),
+    disease = disease,
+    caseId = None,
+    physician = None,
+    sourceName = filename,
+    meta = None,
+    predictedMeta = None,
+    predictedDocuments = None,
+    lastUpdate = LocalDateTime.now()
+  )
+}
+
+object ApiCreateRecord {
+
+  implicit val format: Format[ApiCreateRecord] = Json.format[ApiCreateRecord]
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiRecord.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiRecord.scala
new file mode 100644
index 0000000..6096006
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiRecord.scala
@@ -0,0 +1,57 @@
+package xyz.driver.pdsuidomain.formats.json.record
+
+import java.time.{ZoneId, ZonedDateTime}
+
+import xyz.driver.pdsuidomain.entities.MedicalRecord
+import play.api.data.validation.ValidationError
+import play.api.libs.functional.syntax._
+import play.api.libs.json._
+import xyz.driver.pdsuicommon.json.JsonSerializer
+
+final case class ApiRecord(id: Long,
+                           patientId: String,
+                           caseId: Option[String],
+                           physician: Option[String],
+                           lastUpdate: ZonedDateTime,
+                           status: String,
+                           previousStatus: Option[String],
+                           assignee: Option[Long],
+                           previousAssignee: Option[Long],
+                           meta: String)
+
+object ApiRecord {
+
+  private val statusFormat = Format(
+    Reads.StringReads.filter(ValidationError("unknown status")) {
+      case x if MedicalRecordStatus.statusFromString.isDefinedAt(x) => true
+      case _ => false
+    },
+    Writes.StringWrites
+  )
+
+  implicit val format: Format[ApiRecord] = (
+    (JsPath \ "id").format[Long] and
+      (JsPath \ "patientId").format[String] and
+      (JsPath \ "caseId").formatNullable[String] and
+      (JsPath \ "physician").formatNullable[String] and
+      (JsPath \ "lastUpdate").format[ZonedDateTime] and
+      (JsPath \ "status").format(statusFormat) and
+      (JsPath \ "previousStatus").formatNullable(statusFormat) and
+      (JsPath \ "assignee").formatNullable[Long] and
+      (JsPath \ "previousAssignee").formatNullable[Long] and
+      (JsPath \ "meta").format(Format(Reads { x => JsSuccess(Json.stringify(x)) }, Writes[String](Json.parse)))
+    ) (ApiRecord.apply, unlift(ApiRecord.unapply))
+
+  def fromDomain(record: MedicalRecord) = ApiRecord(
+    id = record.id.id,
+    patientId = record.patientId.toString,
+    caseId = record.caseId.map(_.id),
+    physician = record.physician,
+    lastUpdate = ZonedDateTime.of(record.lastUpdate, ZoneId.of("Z")),
+    status = MedicalRecordStatus.statusToString(record.status),
+    previousStatus = record.previousStatus.map(MedicalRecordStatus.statusToString),
+    assignee = record.assignee.map(_.id),
+    previousAssignee = record.previousAssignee.map(_.id),
+    meta = record.meta.map(x => JsonSerializer.serialize(x.content)).getOrElse("[]")
+  )
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiUpdateRecord.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiUpdateRecord.scala
new file mode 100644
index 0000000..b752a4c
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiUpdateRecord.scala
@@ -0,0 +1,47 @@
+package xyz.driver.pdsuidomain.formats.json.record
+
+import xyz.driver.pdsuidomain.entities.MedicalRecord.Meta
+import xyz.driver.pdsuidomain.entities._
+import xyz.driver.pdsuicommon.domain.{LongId, TextJson, User}
+import org.davidbild.tristate.Tristate
+import org.davidbild.tristate.contrib.play.ToJsPathOpsFromJsPath
+import play.api.data.validation.ValidationError
+import play.api.libs.functional.syntax._
+import play.api.libs.json._
+import xyz.driver.pdsuicommon.json.JsonSerializer
+
+final case class ApiUpdateRecord(status: Option[String],
+                                 assignee: Tristate[Long],
+                                 meta: Tristate[String]) {
+
+  def applyTo(orig: MedicalRecord): MedicalRecord = {
+    orig.copy(
+      status = status.map(MedicalRecordStatus.statusFromString).getOrElse(orig.status),
+      assignee = assignee.map(LongId[User]).cata(Some(_), None, orig.assignee),
+      meta = meta.cata(x => Some(TextJson(JsonSerializer.deserialize[List[Meta]](x))), None, orig.meta)
+    )
+  }
+}
+
+object ApiUpdateRecord {
+
+  private val reads: Reads[ApiUpdateRecord] = (
+    (JsPath \ "status").readNullable[String](Reads.of[String].filter(ValidationError("unknown status"))({
+      case x if MedicalRecordStatus.statusFromString.isDefinedAt(x) => true
+      case _ => false
+    })) and
+      (JsPath \ "assignee").readTristate[Long] and
+      (JsPath \ "meta").readTristate(Reads { x => JsSuccess(Json.stringify(x)) }).map {
+        case Tristate.Present("{}") => Tristate.Absent
+        case x => x
+      }
+    ) (ApiUpdateRecord.apply _)
+
+  private val writes: Writes[ApiUpdateRecord] = (
+    (JsPath \ "status").writeNullable[String] and
+      (JsPath \ "assignee").writeTristate[Long] and
+      (JsPath \ "meta").writeTristate(Writes[String](Json.parse))
+    ) (unlift(ApiUpdateRecord.unapply))
+
+  implicit val format: Format[ApiUpdateRecord] = Format(reads, writes)
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/MedicalRecordStatus.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/MedicalRecordStatus.scala
new file mode 100644
index 0000000..bde4af0
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/MedicalRecordStatus.scala
@@ -0,0 +1,34 @@
+package xyz.driver.pdsuidomain.formats.json.record
+
+import xyz.driver.pdsuidomain.entities.MedicalRecord.Status
+
+object MedicalRecordStatus {
+
+  val statusFromString: PartialFunction[String, Status] = {
+    case "Unprocessed" => Status.Unprocessed
+    case "PreCleaning" => Status.PreCleaning
+    case "New" => Status.New
+    case "Cleaned" => Status.Cleaned
+    case "PreOrganized" => Status.PreOrganized
+    case "PreOrganizing" => Status.PreOrganizing
+    case "Reviewed" => Status.Reviewed
+    case "Organized" => Status.Organized
+    case "Done" => Status.Done
+    case "Flagged" => Status.Flagged
+    case "Archived" => Status.Archived
+  }
+
+  def statusToString(x: Status): String = x match {
+    case Status.Unprocessed => "Unprocessed"
+    case Status.PreCleaning => "PreCleaning"
+    case Status.New => "New"
+    case Status.Cleaned => "Cleaned"
+    case Status.PreOrganized => "PreOrganized"
+    case Status.PreOrganizing => "PreOrganizing"
+    case Status.Reviewed => "Reviewed"
+    case Status.Organized => "Organized"
+    case Status.Done => "Done"
+    case Status.Flagged => "Flagged"
+    case Status.Archived => "Archived"
+  }
+}