Merge pull request #32 from drivergroup/PDSUI-rep-fixtures

Implemented generators of entities for ReP; Implemented json objects for swagger model

8 files changed, 576 insertions, 4 deletions

diff --git a/src/main/scala/xyz/driver/pdsuicommon/utils/CustomSwaggerJsonFormats.scala b/src/main/scala/xyz/driver/pdsuicommon/utils/CustomSwaggerJsonFormats.scala
index 6c87858..4ecf915 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/utils/CustomSwaggerJsonFormats.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/utils/CustomSwaggerJsonFormats.scala
@@ -4,7 +4,7 @@ import java.time.{LocalDate, LocalDateTime}
 
 import io.swagger.models.properties.Property
 import spray.json.JsValue
-import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId}
+import xyz.driver.pdsuicommon.domain.{LongId, StringId, TextJson, UuidId}
 import xyz.driver.pdsuidomain.entities._
 import xyz.driver.pdsuidomain.formats.json.sprayformats.arm._
 import xyz.driver.pdsuidomain.formats.json.sprayformats.criterion._
@@ -15,25 +15,29 @@ import xyz.driver.pdsuidomain.formats.json.sprayformats.trial._
 import xyz.driver.pdsuidomain.formats.json.sprayformats.trialhistory._
 import xyz.driver.pdsuidomain.formats.json.sprayformats.trialissue._
 import xyz.driver.core.swagger.CustomSwaggerJsonConverter._
+import xyz.driver.pdsuicommon.concurrent.BridgeUploadQueue
 import xyz.driver.pdsuidomain.services.CriterionService.RichCriterion
+import xyz.driver.pdsuidomain.services.ExtractedDataService.RichExtractedData
+
+import scala.collection.immutable
 
 object CustomSwaggerJsonFormats {
 
-  val customCommonProperties = Map[Class[_], Property](
+  val customCommonProperties = immutable.Map[Class[_], Property](
     classOf[LocalDateTime] -> stringProperty(example = Some("2010-12-31'T'18:59:59Z")),
     classOf[LocalDate]     -> stringProperty(example = Some("2010-12-31")),
     classOf[UuidId[_]]     -> stringProperty(example = Some("370b0450-35cb-4aab-ba74-0145be75add5")),
     classOf[StringId[_]]   -> stringProperty(),
     classOf[LongId[_]]     -> stringProperty()
   )
-  val customTrialCurationProperties = Map[Class[_], Property](
+  val customTrialCurationProperties = immutable.Map[Class[_], Property](
     classOf[Trial.Status]        -> stringProperty(),
     classOf[Trial.Condition]     -> stringProperty(),
     classOf[TrialHistory.Action] -> stringProperty(),
     classOf[TrialHistory.State]  -> stringProperty()
   ) ++ customCommonProperties
 
-  val customTrialCurationObjectsExamples = Map[Class[_], JsValue](
+  val customTrialCurationObjectsExamples = immutable.Map[Class[_], JsValue](
     classOf[Trial] -> trialWriter.write(xyz.driver.pdsuidomain.fakes.entities.trialcuration.nextTrial()),
     classOf[Arm]   -> armFormat.write(xyz.driver.pdsuidomain.fakes.entities.trialcuration.nextArm()),
     classOf[TrialHistory] -> trialHistoryFormat.write(
@@ -52,4 +56,73 @@ object CustomSwaggerJsonFormats {
       xyz.driver.pdsuidomain.fakes.entities.trialcuration.nextStudyDesign())
   )
 
+  // records-processing-service
+  object Rep {
+    import xyz.driver.pdsuidomain.fakes.entities.rep
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.document
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.documentissue
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.documenthistory
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.providertype
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.record
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.recordissue
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.recordhistory
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.bridgeuploadqueue
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.extracteddata
+
+    val customRepObjectsExamples = immutable.Map[Class[_], JsValue](
+      classOf[Document] ->
+        document.documentFormat.write(rep.DocumentGen.nextDocument()),
+      classOf[Document.Meta] ->
+        document.documentMetaFormat.write(rep.DocumentGen.nextDocumentMeta()),
+      classOf[TextJson[Document.Meta]] ->
+        document.fullDocumentMetaFormat.write(rep.DocumentGen.nextDocumentMetaJson()),
+      classOf[Document.RequiredType] ->
+        document.requiredTypeFormat.write(rep.DocumentGen.nextDocumentRequiredType()),
+      classOf[Document.Status] ->
+        document.documentStatusFormat.write(rep.DocumentGen.nextDocumentStatus()),
+      classOf[DocumentIssue] ->
+        documentissue.documentIssueFormat.write(rep.DocumentGen.nextDocumentIssue()),
+      classOf[DocumentHistory] ->
+        documenthistory.documentHistoryFormat.write(rep.DocumentGen.nextDocumentHistory()),
+      classOf[DocumentHistory.Action] ->
+        documenthistory.documentActionFormat.write(rep.DocumentGen.nextDocumentHistoryAction()),
+      classOf[DocumentHistory.State] ->
+        documenthistory.documentStateFormat.write(rep.DocumentGen.nextDocumentHistoryState()),
+      classOf[ProviderType] ->
+        providertype.providerTypeFormat.write(rep.ProviderTypeGen.nextProviderType()),
+      classOf[TextJson[List[MedicalRecord.Meta]]] ->
+        record.recordMetaFormat.write(rep.MedicalRecordGen.nextMedicalRecordMetasJson()),
+      classOf[MedicalRecord] ->
+        record.recordFormat.write(rep.MedicalRecordGen.nextMedicalRecord()),
+      classOf[MedicalRecord.Meta] ->
+        record.recordMetaTypeFormat.write(rep.MedicalRecordGen.nextMedicalRecordMeta()),
+      classOf[MedicalRecord.Status] ->
+        record.recordStatusFormat.write(rep.MedicalRecordGen.nextMedicalRecordStatus()),
+      classOf[MedicalRecordIssue] ->
+        recordissue.recordIssueFormat.write(rep.MedicalRecordGen.nextMedicalRecordIssue()),
+      classOf[MedicalRecordHistory] ->
+        recordhistory.recordHistoryFormat.write(rep.MedicalRecordGen.nextMedicalRecordHistory()),
+      classOf[MedicalRecordHistory.Action] ->
+        recordhistory.recordActionFormat.write(rep.MedicalRecordGen.nextMedicalRecordHistoryAction()),
+      classOf[MedicalRecordHistory.State] ->
+        recordhistory.recordStateFormat.write(rep.MedicalRecordGen.nextMedicalRecordHistoryState()),
+      classOf[BridgeUploadQueue.Item] ->
+        bridgeuploadqueue.queueUploadItemFormat.write(rep.BridgeUploadQueueGen.nextBridgeUploadQueueItem()),
+      classOf[ExtractedData.Meta] ->
+        extracteddata.extractedDataMetaFormat.write(rep.ExtractedDataGen.nextExtractedDataMeta()),
+      classOf[ExtractedData.Meta.Evidence] ->
+        extracteddata.metaEvidenceFormat.write(rep.ExtractedDataGen.nextExtractedDataMetaEvidence()),
+      classOf[ExtractedData.Meta.Keyword] ->
+        extracteddata.metaKeywordFormat.write(rep.ExtractedDataGen.nextExtractedDataMetaKeyword()),
+      classOf[ExtractedData.Meta.TextLayerPosition] ->
+        extracteddata.metaTextLayerPositionFormat.write(rep.ExtractedDataGen.nextExtractedDataMetaTextLayerPosition()),
+      classOf[TextJson[ExtractedData.Meta]] ->
+        extracteddata.fullExtractedDataMetaFormat.write(rep.ExtractedDataGen.nextExtractedDataMetaJson()),
+      classOf[RichExtractedData] ->
+        extracteddata.extractedDataFormat.write(rep.ExtractedDataGen.nextRichExtractedData()),
+      classOf[ExtractedDataLabel] ->
+        extracteddata.extractedDataLabelWriter.write(rep.ExtractedDataGen.nextExtractedDataLabel())
+    )
+  }
+
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/BridgeUploadQueueGen.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/BridgeUploadQueueGen.scala
new file mode 100644
index 0000000..e7cbd19
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/BridgeUploadQueueGen.scala
@@ -0,0 +1,22 @@
+package xyz.driver.pdsuidomain.fakes.entities.rep
+
+import xyz.driver.core.generators.{nextBoolean, nextInt, nextOption, nextString}
+import xyz.driver.pdsuicommon.concurrent.BridgeUploadQueue
+import xyz.driver.pdsuidomain.fakes.entities.common.nextLocalDateTime
+
+object BridgeUploadQueueGen {
+  private val maxAttemptsNumber = 100
+
+  def nextBridgeUploadQueueItem(): BridgeUploadQueue.Item = {
+    BridgeUploadQueue.Item(
+      kind = nextString(),
+      tag = nextString(),
+      created = nextLocalDateTime,
+      attempts = nextInt(maxAttemptsNumber, minValue = 0),
+      nextAttempt = nextLocalDateTime,
+      completed = nextBoolean(),
+      dependencyKind = nextOption(nextString()),
+      dependencyTag = nextOption(nextString())
+    )
+  }
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/Common.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/Common.scala
new file mode 100644
index 0000000..9618eed
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/Common.scala
@@ -0,0 +1,35 @@
+package xyz.driver.pdsuidomain.fakes.entities.rep
+
+import xyz.driver.core.generators
+import xyz.driver.core.generators._
+import xyz.driver.pdsuicommon.domain.FuzzyValue
+
+private[rep] object Common {
+  def genBoundedRange[T](from: T, to: T)(implicit ord: Ordering[T]): (T, T) = {
+    if (ord.compare(from, to) > 0) {
+      to -> from
+    } else {
+      from -> to
+    }
+  }
+
+  def genBoundedRangeOption[T](from: T, to: T)(implicit ord: Ordering[T]): (Option[T], Option[T]) = {
+    val ranges = nextOption(from)
+      .map(left => genBoundedRange(left, to))
+      .map {
+        case (left, right) =>
+          left -> nextOption(right)
+      }
+
+    ranges.map(_._1) -> ranges.flatMap(_._2)
+  }
+
+  def nextFuzzyValue(): FuzzyValue = {
+    generators.oneOf[FuzzyValue](FuzzyValue.All)
+  }
+
+  def nextStartAndEndPages: (Option[Double], Option[Double]) = {
+    genBoundedRangeOption[Double](nextDouble(), nextDouble())
+  }
+
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/DocumentGen.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/DocumentGen.scala
new file mode 100644
index 0000000..10349bb
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/DocumentGen.scala
@@ -0,0 +1,110 @@
+package xyz.driver.pdsuidomain.fakes.entities.rep
+
+import java.time.LocalDate
+
+import xyz.driver.core.generators
+import xyz.driver.core.generators.{nextBoolean, nextDouble, nextOption, nextString}
+import xyz.driver.pdsuicommon.domain.{LongId, TextJson, User}
+import xyz.driver.pdsuidomain.entities._
+import xyz.driver.pdsuidomain.fakes.entities.common.{nextLocalDate, nextLocalDateTime, nextLongId, nextStringId}
+
+object DocumentGen {
+  implicit private class LocalDateOrdering(localData: LocalDate) extends Ordered[LocalDate] {
+
+    override def compare(that: LocalDate): Int = {
+      this.localData.compareTo(that)
+    }
+  }
+
+  private def nextDates() =
+    Common.genBoundedRangeOption[LocalDate](nextLocalDate, nextLocalDate)
+
+  private def nextStartAndEndPagesOption() =
+    Common.nextStartAndEndPages
+
+  private def nextStartAndEndPage() =
+    Common.genBoundedRange(nextDouble(), nextDouble())
+
+  def nextDocumentStatus(): Document.Status =
+    Document.Status.New
+
+  def nextDocumentRequiredType(): Document.RequiredType =
+    generators.oneOf[Document.RequiredType](Document.RequiredType.All)
+
+  def nextDocumentHistoryState(): DocumentHistory.State =
+    generators.oneOf[DocumentHistory.State](DocumentHistory.State.All)
+
+  def nextDocumentHistoryAction(): DocumentHistory.Action =
+    generators.oneOf[DocumentHistory.Action](DocumentHistory.Action.All)
+
+  def nextDocumentMeta(): Document.Meta = {
+    val (startPage, endPage) = nextStartAndEndPage()
+
+    Document.Meta(
+      nextOption(nextBoolean()),
+      startPage,
+      endPage
+    )
+  }
+
+  def nextDocumentMetaJson(): TextJson[Document.Meta] = {
+    TextJson(nextDocumentMeta())
+  }
+
+  def nextDocument(): Document = {
+    val dates = nextDates()
+
+    Document(
+      id = nextLongId[Document],
+      status = nextDocumentStatus(),
+      previousStatus = None,
+      assignee = nextOption(nextStringId[User]),
+      previousAssignee = nextOption(nextStringId[User]),
+      lastActiveUserId = nextOption(nextStringId[User]),
+      recordId = nextLongId[MedicalRecord],
+      physician = nextOption(nextString()),
+      typeId = nextOption(nextLongId[DocumentType]),
+      providerName = nextOption(nextString()),
+      providerTypeId = nextOption(nextLongId[ProviderType]),
+      requiredType = nextOption(nextDocumentRequiredType()),
+      meta = nextOption(nextDocumentMetaJson()),
+      startDate = dates._1,
+      endDate = dates._2,
+      lastUpdate = nextLocalDateTime
+    )
+  }
+
+  def nextDocumentType(): DocumentType = {
+    DocumentType(
+      id = nextLongId[DocumentType],
+      name = nextString()
+    )
+  }
+
+  def nextDocumentIssue(documentId: LongId[Document] = nextLongId): DocumentIssue = {
+    val pages = nextStartAndEndPagesOption()
+
+    DocumentIssue(
+      id = nextLongId[DocumentIssue],
+      userId = nextStringId[User],
+      documentId = documentId,
+      startPage = pages._1,
+      endPage = pages._2,
+      lastUpdate = nextLocalDateTime,
+      isDraft = nextBoolean(),
+      text = nextString(),
+      archiveRequired = nextBoolean()
+    )
+  }
+
+  def nextDocumentHistory(documentId: LongId[Document] = nextLongId): DocumentHistory = {
+    DocumentHistory(
+      id = nextLongId[DocumentHistory],
+      executor = nextStringId[User],
+      documentId = documentId,
+      state = nextDocumentHistoryState(),
+      action = nextDocumentHistoryAction(),
+      created = nextLocalDateTime
+    )
+  }
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExportPatientGen.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExportPatientGen.scala
new file mode 100644
index 0000000..c2909f3
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExportPatientGen.scala
@@ -0,0 +1,69 @@
+package xyz.driver.pdsuidomain.fakes.entities.rep
+
+import xyz.driver.core.generators._
+import xyz.driver.pdsuicommon.domain.{LongId, UuidId}
+import xyz.driver.pdsuidomain.entities._
+import xyz.driver.pdsuidomain.entities.export.patient.{
+  ExportPatientLabel,
+  ExportPatientLabelEvidence,
+  ExportPatientLabelEvidenceDocument,
+  ExportPatientWithLabels
+}
+import xyz.driver.pdsuidomain.fakes.entities.common.{nextLocalDate, nextLongId}
+
+object ExportPatientGen {
+  private val maxItemsInCollectionNumber = 3
+
+  def nextDocumentType(documentTypeId: LongId[DocumentType] = nextLongId): DocumentType = {
+    DocumentType(
+      documentTypeId,
+      nextString()
+    )
+  }
+
+  def nextProviderType(providerTypeId: LongId[ProviderType] = nextLongId): ProviderType = {
+    ProviderType(
+      providerTypeId,
+      nextString()
+    )
+  }
+
+  def nextExportPatientLabelEvidenceDocument(documentId: LongId[Document]): ExportPatientLabelEvidenceDocument = {
+    ExportPatientLabelEvidenceDocument(
+      documentId = documentId,
+      requestId = RecordRequestId(nextUuid()),
+      documentType = nextDocumentType(),
+      providerType = nextProviderType(),
+      date = nextLocalDate
+    )
+  }
+
+  def nextExportPatientLabelEvidence(documentId: LongId[Document]): ExportPatientLabelEvidence = {
+    ExportPatientLabelEvidence(
+      id = nextLongId[ExtractedData],
+      value = Common.nextFuzzyValue(),
+      evidenceText = nextString(),
+      document = nextExportPatientLabelEvidenceDocument(documentId)
+    )
+  }
+
+  def nextExportPatientLabel(documentId: LongId[Document]): ExportPatientLabel = {
+    ExportPatientLabel(
+      id = nextLongId[Label],
+      evidences = List.fill(
+        nextInt(maxItemsInCollectionNumber, minValue = 0)
+      )(nextExportPatientLabelEvidence(documentId))
+    )
+  }
+
+  def nextExportPatientWithLabels(documentId: LongId[Document]): ExportPatientWithLabels = {
+    ExportPatientWithLabels(
+      patientId = UuidId[xyz.driver.pdsuidomain.entities.Patient](nextUuid()),
+      labelVersion = scala.util.Random.nextLong(),
+      labels = List.fill(
+        nextInt(maxItemsInCollectionNumber, minValue = 0)
+      )(nextExportPatientLabel(documentId))
+    )
+  }
+
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExtractedDataGen.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExtractedDataGen.scala
new file mode 100644
index 0000000..8ac07d0
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExtractedDataGen.scala
@@ -0,0 +1,105 @@
+package xyz.driver.pdsuidomain.fakes.entities.rep
+
+import xyz.driver.core.generators._
+import xyz.driver.pdsuicommon.domain.{LongId, TextJson}
+import xyz.driver.pdsuidomain.entities._
+import xyz.driver.pdsuidomain.entities.ExtractedData.Meta
+import xyz.driver.pdsuidomain.fakes.entities.common._
+import xyz.driver.pdsuidomain.services.ExtractedDataService.RichExtractedData
+
+object ExtractedDataGen {
+  private val maxItemsInCollectionNumber = 50
+
+  private val maxPageNumber   = 100
+  private val maxIndexNumber  = 100
+  private val maxOffsetNumber = 10
+
+  implicit private class TextLayerPositionOrdering(textLayerPosition: ExtractedData.Meta.TextLayerPosition)
+      extends Ordered[ExtractedData.Meta.TextLayerPosition] {
+    override def compare(that: Meta.TextLayerPosition): Int = {
+      if (this.textLayerPosition.page < that.page) -1
+      else if (this.textLayerPosition.page > that.page) 1
+      else if (this.textLayerPosition.index < that.index) -1
+      else if (this.textLayerPosition.index > that.index) 1
+      else if (this.textLayerPosition.offset < that.offset) -1
+      else if (this.textLayerPosition.offset > that.offset) 1
+      else 0
+    }
+  }
+
+  def nextExtractedDataMetaKeyword(): Meta.Keyword = {
+    ExtractedData.Meta.Keyword(
+      page = nextInt(maxPageNumber, minValue = 0),
+      pageRatio = nextOption(nextDouble()),
+      index = nextInt(maxIndexNumber, minValue = 0),
+      sortIndex = nextString()
+    )
+  }
+
+  def nextExtractedDataMetaTextLayerPosition(): Meta.TextLayerPosition = {
+    ExtractedData.Meta.TextLayerPosition(
+      page = nextInt(maxPageNumber, minValue = 0),
+      index = nextInt(maxIndexNumber, minValue = 0),
+      offset = nextInt(maxOffsetNumber, minValue = 0)
+    )
+  }
+
+  def nextExtractedDataMetaEvidence(): Meta.Evidence = {
+    val layersPosition =
+      Common.genBoundedRange[ExtractedData.Meta.TextLayerPosition](
+        nextExtractedDataMetaTextLayerPosition(),
+        nextExtractedDataMetaTextLayerPosition()
+      )
+
+    ExtractedData.Meta.Evidence(
+      pageRatio = nextDouble(),
+      start = layersPosition._1,
+      end = layersPosition._2
+    )
+  }
+
+  def nextExtractedDataMeta(): Meta = {
+    ExtractedData.Meta(
+      nextExtractedDataMetaKeyword(),
+      nextExtractedDataMetaEvidence()
+    )
+  }
+
+  def nextExtractedDataMetaJson(): TextJson[Meta] = {
+    TextJson(
+      ExtractedData.Meta(
+        nextExtractedDataMetaKeyword(),
+        nextExtractedDataMetaEvidence()
+      )
+    )
+  }
+
+  def nextExtractedData(documentId: LongId[Document]): ExtractedData = {
+    ExtractedData(
+      id = nextLongId[ExtractedData],
+      documentId = documentId,
+      keywordId = nextOption(nextLongId[xyz.driver.pdsuidomain.entities.Keyword]),
+      evidenceText = nextOption(nextString()),
+      meta = nextOption(nextExtractedDataMetaJson())
+    )
+  }
+
+  def nextExtractedDataLabel(): ExtractedDataLabel = {
+    ExtractedDataLabel(
+      id = nextLongId[ExtractedDataLabel],
+      dataId = nextLongId[ExtractedData],
+      labelId = nextOption(nextLongId[Label]),
+      categoryId = nextOption(nextLongId[Category]),
+      value = nextOption(Common.nextFuzzyValue())
+    )
+  }
+
+  def nextRichExtractedData(documentId: LongId[Document] = nextLongId): RichExtractedData = {
+    RichExtractedData(
+      extractedData = nextExtractedData(documentId),
+      labels = List.fill(
+        nextInt(maxItemsInCollectionNumber, minValue = 0)
+      )(nextExtractedDataLabel())
+    )
+  }
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/MedicalRecordGen.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/MedicalRecordGen.scala
new file mode 100644
index 0000000..7221e66
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/MedicalRecordGen.scala
@@ -0,0 +1,144 @@
+package xyz.driver.pdsuidomain.fakes.entities.rep
+
+import xyz.driver.pdsuidomain.entities._
+import xyz.driver.core.generators
+import xyz.driver.core.generators._
+import xyz.driver.pdsuicommon.domain.{LongId, TextJson, User}
+import xyz.driver.pdsuidomain.fakes.entities.common.{nextLocalDateTime, nextLongId, nextStringId, nextUuidId}
+
+object MedicalRecordGen {
+  private val maxItemsInCollectionNumber: Int = 50
+
+  private val pageMaxNumber: Int = 1000
+
+  private val medicalRecordMetas: Set[() => MedicalRecord.Meta] = {
+    Set(
+      () => nextMedicalRecordMetaReorder(),
+      () => nextMedicalRecordMetaDuplicate(),
+      () => nextMedicalRecordMetaRotation()
+    )
+  }
+
+  def nextMedicalRecordMetas(count: Int): List[MedicalRecord.Meta] =
+    List.fill(count)(nextMedicalRecordMeta())
+
+  def nextMedicalRecordMetasJson(): TextJson[List[MedicalRecord.Meta]] =
+    TextJson(nextMedicalRecordMetas(nextInt(maxItemsInCollectionNumber, minValue = 0)))
+
+  private def nextDocument(): Document =
+    DocumentGen.nextDocument()
+
+  private def nextDocuments(count: Int): List[Document] =
+    List.fill(count)(nextDocument())
+
+  def nextDocuments(recordId: LongId[MedicalRecord]): TextJson[List[Document]] = {
+    val documents = nextDocuments(
+      nextInt(maxItemsInCollectionNumber, minValue = 0)
+    )
+
+    TextJson(documents.map(_.copy(recordId = recordId)))
+  }
+
+  def nextMedicalRecordStatus(): MedicalRecord.Status =
+    MedicalRecord.Status.New
+
+  def nextMedicalRecordHistoryState(): MedicalRecordHistory.State =
+    generators.oneOf[MedicalRecordHistory.State](MedicalRecordHistory.State.All)
+
+  def nextMedicalRecordHistoryAction(): MedicalRecordHistory.Action =
+    generators.oneOf[MedicalRecordHistory.Action](MedicalRecordHistory.Action.All)
+
+  def nextMedicalRecordMetaReorder(): MedicalRecord.Meta.Reorder = {
+    val itemsNumber =
+      maxItemsInCollectionNumber
+    val items = scala.util.Random
+      .shuffle(Seq.tabulate(itemsNumber)(identity))
+
+    MedicalRecord.Meta.Reorder(
+      predicted = nextOption(nextBoolean),
+      items = items
+    )
+  }
+
+  def nextMedicalRecordMetaDuplicate(): MedicalRecord.Meta.Duplicate = {
+    val startPageGen =
+      nextInt(pageMaxNumber, minValue = 0)
+    val endPageGen =
+      nextInt(pageMaxNumber, startPageGen)
+
+    MedicalRecord.Meta.Duplicate(
+      predicted = nextOption(nextBoolean),
+      startPage = startPageGen.toDouble,
+      endPage = endPageGen.toDouble,
+      startOriginalPage = startPageGen.toDouble,
+      endOriginalPage = nextOption(endPageGen.toDouble)
+    )
+  }
+
+  def nextMedicalRecordMetaRotation(): MedicalRecord.Meta.Rotation = {
+    val items =
+      Array
+        .tabulate(maxItemsInCollectionNumber)(
+          index => nextString() -> index
+        )
+        .toMap
+
+    MedicalRecord.Meta.Rotation(
+      predicted = nextOption(nextBoolean()),
+      items = items
+    )
+  }
+
+  def nextMedicalRecordMeta(): MedicalRecord.Meta = {
+    generators.oneOf(medicalRecordMetas)()
+  }
+
+  def nextMedicalRecord(): MedicalRecord = {
+    val id = nextLongId[MedicalRecord]
+    MedicalRecord(
+      id = nextLongId[MedicalRecord],
+      status = nextMedicalRecordStatus(),
+      previousStatus = None,
+      assignee = nextOption(nextStringId),
+      previousAssignee = nextOption(nextStringId),
+      lastActiveUserId = nextOption(nextStringId),
+      patientId = nextUuidId,
+      requestId = RecordRequestId(generators.nextUuid()),
+      disease = generators.nextString(),
+      caseId = nextOption(CaseId(generators.nextString())),
+      physician = nextOption(generators.nextString()),
+      meta = nextOption(nextMedicalRecordMetasJson()),
+      predictedMeta = nextOption(nextMedicalRecordMetasJson()),
+      predictedDocuments = nextOption(nextDocuments(id)),
+      lastUpdate = nextLocalDateTime
+    )
+  }
+
+  def nextMedicalRecordHistory(): MedicalRecordHistory = {
+    MedicalRecordHistory(
+      id = nextLongId[MedicalRecordHistory],
+      executor = nextStringId[User],
+      recordId = nextLongId[MedicalRecord],
+      state = nextMedicalRecordHistoryState(),
+      action = nextMedicalRecordHistoryAction(),
+      created = nextLocalDateTime
+    )
+  }
+
+  def nextMedicalRecordIssue(): MedicalRecordIssue = {
+    val pages = Common.nextStartAndEndPages
+
+    MedicalRecordIssue(
+      id = nextLongId[MedicalRecordIssue],
+      userId = nextStringId[User],
+      recordId = nextLongId[MedicalRecord],
+      startPage = pages._1,
+      endPage = pages._2,
+      lastUpdate = nextLocalDateTime,
+      isDraft = nextBoolean(),
+      text = nextString(),
+      archiveRequired = nextBoolean()
+    )
+  }
+
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ProviderTypeGen.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ProviderTypeGen.scala
new file mode 100644
index 0000000..168f7af
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ProviderTypeGen.scala
@@ -0,0 +1,14 @@
+package xyz.driver.pdsuidomain.fakes.entities.rep
+
+import xyz.driver.core.generators.nextString
+import xyz.driver.pdsuidomain.entities.ProviderType
+import xyz.driver.pdsuidomain.fakes.entities.common.nextLongId
+
+object ProviderTypeGen {
+  def nextProviderType(): ProviderType = {
+    ProviderType(
+      id = nextLongId[ProviderType],
+      name = nextString()
+    )
+  }
+}