From d8e71e0a9ee7db58032384d059403bc227a35138 Mon Sep 17 00:00:00 2001 From: Aleksandr Date: Thu, 28 Sep 2017 13:31:21 +0700 Subject: Implemented some REP entities objects generators --- .../pdsuidomain/fakes/entities/rep/Common.scala | 35 ++++++++++ .../fakes/entities/rep/DocumentGen.scala | 68 ++++++++++++++++++++ .../fakes/entities/rep/ExtractedDataGen.scala | 74 ++++++++++++++++++++++ .../fakes/entities/rep/MedicalRecordMetaGen.scala | 63 ++++++++++++++++++ 4 files changed, 240 insertions(+) create mode 100644 src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/Common.scala create mode 100644 src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/DocumentGen.scala create mode 100644 src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExtractedDataGen.scala create mode 100644 src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/MedicalRecordMetaGen.scala (limited to 'src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep') 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..d09e09b --- /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._ + +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 genStartAndEndPages: (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..1c77a78 --- /dev/null +++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/DocumentGen.scala @@ -0,0 +1,68 @@ +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.{TextJson, User} +import xyz.driver.pdsuidomain.entities.{Document, DocumentType, MedicalRecord, ProviderType} +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) + } + } + + def nextDocumentStatus: Document.Status = + generators.oneOf[Document.Status](Document.Status.All) + + def nextDocumentRequiredType: Document.RequiredType = + generators.oneOf[Document.RequiredType](Document.RequiredType.All) + + def nextDocumentMeta: Document.Meta = { + val (startPage, endPage) = { + val startPage = nextDouble() + val endPage = nextDouble() + if (startPage > endPage) { + endPage -> startPage + } + else { + startPage -> endPage + } + } + + Document.Meta( + nextOption(nextBoolean()), startPage, endPage + ) + } + + def nextDocument: Document = { + val dates = Common + .genBoundedRangeOption[LocalDate](nextLocalDate, nextLocalDate) + + Document( + id = nextLongId[Document], + status = nextDocumentStatus, + previousStatus = nextOption(nextDocumentStatus), + 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(TextJson(nextDocumentMeta)), + startDate = dates._1, + endDate = dates._2, + lastUpdate = nextLocalDateTime + ) + } + +} 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..48eaf79 --- /dev/null +++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExtractedDataGen.scala @@ -0,0 +1,74 @@ +package xyz.driver.pdsuidomain.fakes.entities.rep + +import xyz.driver.core.generators._ +import xyz.driver.pdsuidomain.entities.{Document, ExtractedData} +import xyz.driver.pdsuidomain.entities.ExtractedData.Meta +import xyz.driver.pdsuidomain.fakes.entities.common._ + + +object ExtractedDataGen { + 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 nextExtractedData() = { + ExtractedData.apply( + id = nextLongId[ExtractedData], + documentId = nextLongId[Document], + keywordId = nextOption(nextLongId[xyz.driver.pdsuidomain.entities.Keyword]), + evidenceText = nextOption(nextString()), + ??? + ) + } +} diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/MedicalRecordMetaGen.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/MedicalRecordMetaGen.scala new file mode 100644 index 0000000..1536c65 --- /dev/null +++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/MedicalRecordMetaGen.scala @@ -0,0 +1,63 @@ +package xyz.driver.pdsuidomain.fakes.entities.rep + +import xyz.driver.pdsuidomain.entities.MedicalRecord +import xyz.driver.core.generators +import xyz.driver.core.generators._ + +object MedicalRecordMetaGen { + private val maxItemsInCollectionNumber = 50 + private val pageMaxNumber = 1000 + + private val medicalRecordMetas = { + Set( + () => nextMedicalRecordMetaReorder, + () => nextMedicalRecordMetaDuplicate, + () => nextMedicalRecordMetaRotation + ) + } + + + 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)() + } +} -- cgit v1.2.3