Latest PDS UI utils including all the domain stuffv0.1.12

17 files changed, 135 insertions, 73 deletions

diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiNewCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiNewCriterion.scala
index 604a98b..ab7641f 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiNewCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiNewCriterion.scala
@@ -11,6 +11,7 @@ import xyz.driver.pdsuidomain.services.CriterionService.RichCriterion
 final case class ApiNewCriterion(meta: Option[String],
                                  arms: Option[Seq[Long]],
                                  text: Option[String],
+                                 isCompound: Option[Boolean],
                                  labels: Seq[ApiCriterionLabel],
                                  trialId: String) {
 
@@ -19,7 +20,7 @@ final case class ApiNewCriterion(meta: Option[String],
       id = LongId(0L),
       meta = meta.getOrElse(""),
       trialId = StringId(trialId),
-      isCompound = false,
+      isCompound = isCompound.getOrElse(false),
       text = text
     ),
     armIds = arms.getOrElse(Seq.empty).map(LongId[Arm]),
@@ -35,6 +36,7 @@ object ApiNewCriterion {
     }, Writes[String](Json.parse))) and
       (JsPath \ "arms").formatNullable(seqJsonFormat[Long]) and
       (JsPath \ "text").formatNullable[String] and
+      (JsPath \ "isCompound").formatNullable[Boolean] and
       (JsPath \ "labels").format(seqJsonFormat[ApiCriterionLabel]) and
       (JsPath \ "trialId").format[String]
   )(ApiNewCriterion.apply, unlift(ApiNewCriterion.unapply))
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocument.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocument.scala
index 0fd96b3..73b6166 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocument.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocument.scala
@@ -17,18 +17,20 @@ final case class ApiDocument(id: Long,
                              endDate: Option[LocalDate],
                              provider: Option[String],
                              providerTypeId: Option[Long],
+                             requiredType: Option[String],
                              status: Option[String],
                              previousStatus: Option[String],
                              assignee: Option[Long],
                              previousAssignee: Option[Long],
+                             lastActiveUser: Option[Long],
                              meta: Option[String])
 
 object ApiDocument {
 
   private val statusFormat = Format(
     Reads.StringReads.filter(ValidationError("unknown status")) {
-      case x if DocumentUtils.statusFromString.isDefinedAt(x) => true
-      case _                                                  => false
+      case x if Document.RequiredType.fromString.isDefinedAt(x) => true
+      case _                                                    => false
     },
     Writes.StringWrites
   )
@@ -43,10 +45,12 @@ object ApiDocument {
       (JsPath \ "endDate").formatNullable[LocalDate] and
       (JsPath \ "provider").formatNullable[String] and
       (JsPath \ "providerTypeId").formatNullable[Long] and
+      (JsPath \ "requiredType").formatNullable[String] and
       (JsPath \ "status").formatNullable(statusFormat) and
       (JsPath \ "previousStatus").formatNullable(statusFormat) and
       (JsPath \ "assignee").formatNullable[Long] and
       (JsPath \ "previousAssignee").formatNullable[Long] and
+      (JsPath \ "lastActiveUser").formatNullable[Long] and
       (JsPath \ "meta").formatNullable(Format(Reads { x =>
         JsSuccess(Json.stringify(x))
       }, Writes[String](Json.parse)))
@@ -63,10 +67,12 @@ object ApiDocument {
       endDate = document.endDate,
       provider = document.providerName,
       providerTypeId = document.providerTypeId.map(_.id),
-      status = Option(DocumentUtils.statusToString(document.status)),
-      previousStatus = document.previousStatus.map(DocumentUtils.statusToString),
+      requiredType = document.requiredType.map(Document.RequiredType.requiredTypeToString),
+      status = Option(Document.Status.statusToString(document.status)),
+      previousStatus = document.previousStatus.map(Document.Status.statusToString),
       assignee = document.assignee.map(_.id),
       previousAssignee = document.previousAssignee.map(_.id),
+      lastActiveUser = document.lastActiveUserId.map(_.id),
       meta = document.meta.map(meta => JsonSerializer.serialize(meta.content))
     )
   }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiPartialDocument.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiPartialDocument.scala
index 7682bb5..84e9e09 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiPartialDocument.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiPartialDocument.scala
@@ -31,15 +31,17 @@ final case class ApiPartialDocument(recordId: Option[Long],
 
   def applyTo(orig: Document): Document = Document(
     id = orig.id,
-    status = status.map(DocumentUtils.statusFromString).getOrElse(orig.status),
+    status = status.map(Document.Status.fromString).getOrElse(orig.status),
     previousStatus = orig.previousStatus,
     assignee = assignee.map(LongId[User]).cata(Some(_), None, orig.assignee),
     previousAssignee = orig.previousAssignee,
+    lastActiveUserId = orig.lastActiveUserId,
     recordId = recordId.map(LongId[MedicalRecord]).getOrElse(orig.recordId),
     physician = physician.orElse(orig.physician),
     typeId = typeId.map(LongId[DocumentType]).cata(Some(_), None, orig.typeId),
     providerName = provider.cata(Some(_), None, orig.providerName),
     providerTypeId = providerTypeId.map(LongId[ProviderType]).cata(Some(_), None, orig.providerTypeId),
+    requiredType = orig.requiredType,
     meta = meta.cata(x => Some(TextJson(JsonSerializer.deserialize[Meta](x))), None, orig.meta),
     startDate = startDate.cata(Some(_), None, orig.startDate),
     endDate = endDate.cata(Some(_), None, orig.endDate),
@@ -64,10 +66,12 @@ final case class ApiPartialDocument(recordId: Option[Long],
         endDate = endDate.toOption,
         providerName = provider.toOption,
         providerTypeId = providerTypeId.map(LongId[ProviderType]).toOption,
+        requiredType = None,
         meta = meta.map(x => TextJson(JsonSerializer.deserialize[Meta](x))).toOption,
         previousStatus = None,
         assignee = None,
         previousAssignee = None,
+        lastActiveUserId = None,
         lastUpdate = LocalDateTime.MIN
       )
     } else {
@@ -87,7 +91,7 @@ object ApiPartialDocument {
       (JsPath \ "provider").readTristate[String] and
       (JsPath \ "providerTypeId").readTristate[Long] and
       (JsPath \ "status").readNullable[String](Reads.of[String].filter(ValidationError("unknown status"))({
-        case x if DocumentUtils.statusFromString.isDefinedAt(x) => true
+        case x if Document.Status.fromString.isDefinedAt(x) => true
         case _ => false
       })) and
       (JsPath \ "assignee").readTristate[Long] and
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/DocumentUtils.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/DocumentUtils.scala
deleted file mode 100644
index 24e388e..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/DocumentUtils.scala
+++ /dev/null
@@ -1,24 +0,0 @@
-package xyz.driver.pdsuidomain.formats.json.document
-
-import xyz.driver.pdsuidomain.entities.Document.Status
-
-object DocumentUtils {
-
-  val statusFromString: PartialFunction[String, Status] = {
-    case "New"       => Status.New
-    case "Organized" => Status.Organized
-    case "Extracted" => Status.Extracted
-    case "Done"      => Status.Done
-    case "Flagged"   => Status.Flagged
-    case "Archived"  => Status.Archived
-  }
-
-  def statusToString(x: Status): String = x match {
-    case Status.New       => "New"
-    case Status.Organized => "Organized"
-    case Status.Extracted => "Extracted"
-    case Status.Done      => "Done"
-    case Status.Flagged   => "Flagged"
-    case Status.Archived  => "Archived"
-  }
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/evidence/ApiPatientLabelEvidence.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/evidence/ApiPatientLabelEvidence.scala
index 2bb4945..e0f23e3 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/evidence/ApiPatientLabelEvidence.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/evidence/ApiPatientLabelEvidence.scala
@@ -2,9 +2,9 @@ package xyz.driver.pdsuidomain.formats.json.evidence
 
 import java.time.LocalDate
 
-import xyz.driver.pdsuidomain.services.PatientLabelEvidenceService
 import play.api.libs.json._
 import xyz.driver.pdsuicommon.domain.FuzzyValue
+import xyz.driver.pdsuidomain.entities.PatientLabelEvidenceView
 
 final case class ApiPatientLabelEvidence(id: Long,
                                          value: String,
@@ -20,19 +20,15 @@ object ApiPatientLabelEvidence {
 
   implicit val format: Format[ApiPatientLabelEvidence] = Json.format
 
-  def fromDomain(x: PatientLabelEvidenceService.Aggregated): ApiPatientLabelEvidence = {
-    import x._
-
-    ApiPatientLabelEvidence(
-      id = evidence.id.id,
-      value = FuzzyValue.valueToString(evidence.value),
-      evidenceText = evidence.evidenceText,
-      documentId = evidence.documentId.map(_.id),
-      evidenceId = evidence.evidenceId.map(_.id),
-      reportId = evidence.reportId.map(_.toString),
-      documentType = documentType,
-      date = date,
-      providerType = providerType
-    )
-  }
+  def fromDomain(x: PatientLabelEvidenceView) = ApiPatientLabelEvidence(
+    id = x.id.id,
+    value = FuzzyValue.valueToString(x.value),
+    evidenceText = x.evidenceText,
+    documentId = x.documentId.map(_.id),
+    evidenceId = x.evidenceId.map(_.id),
+    reportId = x.reportId.map(_.toString),
+    documentType = x.documentType,
+    date = x.date.get,
+    providerType = x.providerType
+  )
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/linkedpatient/ApiLinkedPatient.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/linkedpatient/ApiLinkedPatient.scala
new file mode 100644
index 0000000..20d4a74
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/linkedpatient/ApiLinkedPatient.scala
@@ -0,0 +1,33 @@
+
+package xyz.driver.pdsuidomain.formats.json.linkedpatient
+
+import java.util.UUID
+
+import play.api.libs.json.{Format, Json}
+import xyz.driver.pdsuicommon.domain._
+import xyz.driver.pdsuidomain.services.LinkedPatientService.RichLinkedPatient
+
+case class ApiLinkedPatient(email: String,
+                            name: String,
+                            patientId: UUID,
+                            trialId: String) {
+
+  def toDomain = RichLinkedPatient(
+    email = Email(email),
+    name = name,
+    patientId = UuidId(patientId),
+    trialId = StringId(trialId)
+  )
+}
+
+object ApiLinkedPatient {
+
+  implicit val format: Format[ApiLinkedPatient] = Json.format[ApiLinkedPatient]
+
+  def fromDomain(entity: RichLinkedPatient) = ApiLinkedPatient(
+    email = entity.email.value,
+    name = entity.name,
+    patientId = entity.patientId.id,
+    trialId =  entity.trialId.id
+  )
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/message/ApiPartialMessage.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/message/ApiPartialMessage.scala
index 8c390e7..88dd5a3 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/message/ApiPartialMessage.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/message/ApiPartialMessage.scala
@@ -50,7 +50,6 @@ final case class ApiPartialMessage(text: Option[String],
       lastUpdate = LocalDateTime.MIN
     )
   }
-
 }
 
 object ApiPartialMessage {
@@ -80,5 +79,4 @@ object ApiPartialMessage {
     archiveRequired = domain.archiveRequired,
     meta = domain.meta
   )
-
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/ApiPatient.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/ApiPatient.scala
index caa556b..68e965c 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/ApiPatient.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/ApiPatient.scala
@@ -13,6 +13,7 @@ final case class ApiPatient(id: String,
                             assignee: Option[Long],
                             previousStatus: Option[String],
                             previousAssignee: Option[Long],
+                            lastActiveUser: Option[Long],
                             lastUpdate: ZonedDateTime,
                             condition: String)
 
@@ -26,6 +27,7 @@ object ApiPatient {
       (JsPath \ "assignee").formatNullable[Long] and
       (JsPath \ "previousStatus").formatNullable[String] and
       (JsPath \ "previousAssignee").formatNullable[Long] and
+      (JsPath \ "lastActiveUser").formatNullable[Long] and
       (JsPath \ "lastUpdate").format[ZonedDateTime] and
       (JsPath \ "condition").format[String]
   )(ApiPatient.apply, unlift(ApiPatient.unapply))
@@ -38,6 +40,7 @@ object ApiPatient {
     assignee = patient.assignee.map(_.id),
     previousStatus = patient.previousStatus.map(PatientStatus.statusToString),
     previousAssignee = patient.previousAssignee.map(_.id),
+    lastActiveUser = patient.lastActiveUserId.map(_.id),
     lastUpdate = ZonedDateTime.of(patient.lastUpdate, ZoneId.of("Z")),
     condition = patient.condition
   )
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/eligible/ApiPatientEligibleTrial.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/eligible/ApiPatientEligibleTrial.scala
index 42c3259..033d73e 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/eligible/ApiPatientEligibleTrial.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/eligible/ApiPatientEligibleTrial.scala
@@ -14,7 +14,7 @@ final case class ApiPatientEligibleTrial(id: Long,
                                          trialTitle: String,
                                          arms: List[String],
                                          hypothesisId: UUID,
-                                         eligibilityStatus: Option[String],
+                                         verifiedEligibilityStatus: Option[String],
                                          isVerified: Boolean)
 
 object ApiPatientEligibleTrial {
@@ -26,7 +26,7 @@ object ApiPatientEligibleTrial {
       (JsPath \ "trialTitle").format[String] and
       (JsPath \ "arms").format[List[String]] and
       (JsPath \ "hypothesisId").format[UUID] and
-      (JsPath \ "eligibilityStatus").formatNullable[String](Format(
+      (JsPath \ "verifiedEligibilityStatus").formatNullable[String](Format(
         Reads
           .of[String]
           .filter(ValidationError("unknown eligibility status"))({
@@ -45,7 +45,7 @@ object ApiPatientEligibleTrial {
     trialTitle = eligibleTrialWithTrial.trial.title,
     arms = eligibleTrialWithTrial.arms.map(_.name),
     hypothesisId = eligibleTrialWithTrial.group.hypothesisId.id,
-    eligibleTrialWithTrial.group.eligibilityStatus.map(FuzzyValue.valueToString),
+    eligibleTrialWithTrial.group.verifiedEligibilityStatus.map(FuzzyValue.valueToString),
     eligibleTrialWithTrial.group.isVerified
   )
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/hypothesis/ApiPatientHypothesis.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/hypothesis/ApiPatientHypothesis.scala
index 374370e..584ff72 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/hypothesis/ApiPatientHypothesis.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/hypothesis/ApiPatientHypothesis.scala
@@ -10,7 +10,8 @@ final case class ApiPatientHypothesis(id: UUID,
                                       patientId: String,
                                       hypothesisId: UUID,
                                       matchedTrials: Long,
-                                      rationale: Option[String])
+                                      rationale: Option[String],
+                                      isRationaleRequired: Boolean)
 
 object ApiPatientHypothesis {
 
@@ -19,14 +20,16 @@ object ApiPatientHypothesis {
       (JsPath \ "patientId").format[String] and
       (JsPath \ "hypothesisId").format[UUID] and
       (JsPath \ "matchedTrials").format[Long] and
-      (JsPath \ "rationale").formatNullable[String]
+      (JsPath \ "rationale").formatNullable[String] and
+      (JsPath \ "isRationaleRequired").format[Boolean]
   )(ApiPatientHypothesis.apply, unlift(ApiPatientHypothesis.unapply))
 
-  def fromDomain(patientHypothesis: PatientHypothesis) = ApiPatientHypothesis(
+  def fromDomain(patientHypothesis: PatientHypothesis, isRationaleRequired: Boolean) = ApiPatientHypothesis(
     id = patientHypothesis.id.id,
     patientId = patientHypothesis.patientId.toString,
     hypothesisId = patientHypothesis.hypothesisId.id,
     matchedTrials = patientHypothesis.matchedTrials,
-    rationale = patientHypothesis.rationale
+    rationale = patientHypothesis.rationale,
+    isRationaleRequired = isRationaleRequired
   )
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPartialPatientLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPartialPatientLabel.scala
index 40f7de4..91d0a0e 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPartialPatientLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/label/ApiPartialPatientLabel.scala
@@ -17,7 +17,6 @@ final case class ApiPartialPatientLabel(primaryValue: Option[String], verifiedPr
         verifiedPrimaryValue.cata(x => Some(FuzzyValue.fromString(x)), None, orig.verifiedPrimaryValue)
     )
   }
-
 }
 
 object ApiPartialPatientLabel {
@@ -42,5 +41,4 @@ object ApiPartialPatientLabel {
           Writes.of[String]
         ))
   )(ApiPartialPatientLabel.apply, unlift(ApiPartialPatientLabel.unapply))
-
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPatientCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPatientCriterion.scala
index 3e2de99..7ac55f6 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPatientCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPatientCriterion.scala
@@ -11,6 +11,7 @@ import play.api.libs.json.{Format, JsPath, Reads, Writes}
 final case class ApiPatientCriterion(id: Long,
                                      labelId: Long,
                                      nctId: String,
+                                     criterionId: Long,
                                      criterionText: String,
                                      criterionValue: Option[String],
                                      criterionIsDefining: Boolean,
@@ -28,6 +29,7 @@ object ApiPatientCriterion {
     (JsPath \ "id").format[Long] and
       (JsPath \ "labelId").format[Long] and
       (JsPath \ "nctId").format[String] and
+      (JsPath \ "criterionId").format[Long] and
       (JsPath \ "criterionText").format[String] and
       (JsPath \ "criterionValue").formatNullable[String](Format(Reads.of[String].filter(ValidationError("unknown value"))({ x =>
         x == "Yes" || x == "No"
@@ -56,6 +58,7 @@ object ApiPatientCriterion {
     id = patientCriterion.id.id,
     labelId = labelId.id,
     nctId = patientCriterion.nctId.id,
+    criterionId = patientCriterion.criterionId.id,
     criterionText = patientCriterion.criterionText,
     criterionValue = patientCriterion.criterionValue.map { x =>
       FuzzyValue.valueToString(FuzzyValue.fromBoolean(x))
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
index cee67b2..e96bc81 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiCreateRecord.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiCreateRecord.scala
@@ -15,6 +15,7 @@ final case class ApiCreateRecord(disease: String, patientId: String, requestId:
     previousStatus = None,
     assignee = None,
     previousAssignee = None,
+    lastActiveUserId = None,
     patientId = UuidId(patientId),
     requestId = RecordRequestId(requestId),
     disease = disease,
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
index de54a9e..dca441b 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiRecord.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/record/ApiRecord.scala
@@ -17,6 +17,7 @@ final case class ApiRecord(id: Long,
                            previousStatus: Option[String],
                            assignee: Option[Long],
                            previousAssignee: Option[Long],
+                           lastActiveUser: Option[Long],
                            meta: String)
 
 object ApiRecord {
@@ -39,6 +40,7 @@ object ApiRecord {
       (JsPath \ "previousStatus").formatNullable(statusFormat) and
       (JsPath \ "assignee").formatNullable[Long] and
       (JsPath \ "previousAssignee").formatNullable[Long] and
+      (JsPath \ "lastActiveUser").formatNullable[Long] and
       (JsPath \ "meta").format(Format(Reads { x =>
         JsSuccess(Json.stringify(x))
       }, Writes[String](Json.parse)))
@@ -54,6 +56,7 @@ object ApiRecord {
     previousStatus = record.previousStatus.map(MedicalRecordStatus.statusToString),
     assignee = record.assignee.map(_.id),
     previousAssignee = record.previousAssignee.map(_.id),
+    lastActiveUser = record.lastActiveUserId.map(_.id),
     meta = record.meta.map(x => JsonSerializer.serialize(x.content)).getOrElse("[]")
   )
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/ApiTrial.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/ApiTrial.scala
index db980ee..97bab5e 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/ApiTrial.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/trial/ApiTrial.scala
@@ -13,6 +13,7 @@ final case class ApiTrial(id: String,
                           assignee: Option[Long],
                           previousStatus: Option[String],
                           previousAssignee: Option[Long],
+                          lastActiveUser: Option[Long],
                           condition: Option[String],
                           phase: Option[String],
                           hypothesisId: Option[UUID],
@@ -32,6 +33,7 @@ object ApiTrial {
       (JsPath \ "assignee").formatNullable[Long] and
       (JsPath \ "previousStatus").formatNullable[String] and
       (JsPath \ "previousAssignee").formatNullable[Long] and
+      (JsPath \ "lastActiveUser").formatNullable[Long] and
       (JsPath \ "condition").formatNullable[String] and
       (JsPath \ "phase").formatNullable[String] and
       (JsPath \ "hypothesisId").formatNullable[UUID] and
@@ -49,6 +51,7 @@ object ApiTrial {
     assignee = trial.assignee.map(_.id),
     previousStatus = trial.previousStatus.map(TrialStatus.statusToString),
     previousAssignee = trial.previousAssignee.map(_.id),
+    lastActiveUser = trial.lastActiveUserId.map(_.id),
     lastUpdate = Option(ZonedDateTime.of(trial.lastUpdate, ZoneId.of("Z"))),
     condition = Option(trial.condition.toString),
     phase = Option(trial.phase),
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/ApiPartialUser.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/ApiPartialUser.scala
index 654508c..a37fea8 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/ApiPartialUser.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/user/ApiPartialUser.scala
@@ -1,8 +1,5 @@
 package xyz.driver.pdsuidomain.formats.json.user
 
-import java.math.BigInteger
-import java.security.SecureRandom
-
 import xyz.driver.pdsuicommon.domain.{Email, LongId, PasswordHash, User}
 import play.api.data.validation._
 import play.api.libs.functional.syntax._
@@ -10,7 +7,7 @@ import play.api.libs.json._
 
 import scala.collection._
 import scala.util.Try
-import ApiPartialUser._
+import User._
 import xyz.driver.pdsuicommon.json.JsonValidationException
 import xyz.driver.pdsuicommon.validation.{AdditionalConstraints, JsonValidationErrors}
 
@@ -62,19 +59,12 @@ final case class ApiPartialUser(email: Option[String], name: Option[String], rol
 
 object ApiPartialUser {
 
-  // SecureRandom is thread-safe, see the implementation
-  private val random = new SecureRandom()
-
-  def createPassword: String = new BigInteger(240, random).toString(32)
-
   implicit val format: Format[ApiPartialUser] = (
     (JsPath \ "email").formatNullable[String](Format(Reads.email, Writes.StringWrites)) and
-      (JsPath \ "name").formatNullable[String](
-        Format(
-          Reads.filterNot[String](ValidationError("Username is too long (max length is 255 chars)", 255))(
-            _.length > 255),
-          Writes.StringWrites
-        )) and
+      (JsPath \ "name").formatNullable[String](Format(
+        Reads.filterNot[String](ValidationError("Username is too long (max length is 255 chars)", 255))(_.size > 255),
+        Writes.StringWrites
+      )) and
       (JsPath \ "roleId").formatNullable[String](
         Format(Reads
                  .of[String]
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/userhistory/ApiUserHistory.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/userhistory/ApiUserHistory.scala
new file mode 100644
index 0000000..befff05
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/userhistory/ApiUserHistory.scala
@@ -0,0 +1,43 @@
+package xyz.driver.pdsuidomain.formats.json.userhistory
+
+import java.time.{ZoneId, ZonedDateTime}
+
+import play.api.libs.functional.syntax._
+import play.api.libs.json.{Format, JsPath}
+import xyz.driver.pdsuidomain.entities.UserHistory
+
+final case class ApiUserHistory(id: Long,
+                                executor: Long,
+                                recordId: Option[Long],
+                                documentId: Option[Long],
+                                trialId: Option[String],
+                                patientId: Option[String],
+                                state: String,
+                                action: String,
+                                created: ZonedDateTime)
+
+object ApiUserHistory {
+  implicit val format: Format[ApiUserHistory] = (
+    (JsPath \ "id").format[Long] and
+      (JsPath \ "executor").format[Long] and
+      (JsPath \ "recordId").formatNullable[Long] and
+      (JsPath \ "documentId").formatNullable[Long] and
+      (JsPath \ "trialId").formatNullable[String] and
+      (JsPath \ "patientId").formatNullable[String] and
+      (JsPath \ "state").format[String] and
+      (JsPath \ "action").format[String] and
+      (JsPath \ "created").format[ZonedDateTime]
+    ) (ApiUserHistory.apply, unlift(ApiUserHistory.unapply))
+
+  def fromDomain(x: UserHistory) = ApiUserHistory(
+    id = x.id.id,
+    executor = x.executor.id,
+    recordId = x.recordId.map(_.id),
+    documentId = x.documentId.map(_.id),
+    trialId = x.trialId.map(_.id),
+    patientId = x.patientId.map(_.id.toString),
+    state = UserHistory.State.stateToString(x.state),
+    action = UserHistory.Action.actionToString(x.action),
+    created = ZonedDateTime.of(x.created, ZoneId.of("Z"))
+  )
+}