diff options
author | Vlad Uspensky <v.uspenskiy@icloud.com> | 2017-09-29 12:42:35 -0700 |
---|---|---|
committer | GitHub <noreply@github.com> | 2017-09-29 12:42:35 -0700 |
commit | 46b354b6a49c0843fefc5794f2351f52b98102bd (patch) | |
tree | 20e9a10e87f0859c5c0342f3eee45d04aa214c64 /src/main/scala/xyz/driver/pdsuidomain | |
parent | deba20326e3269fee3ef51f8e6841f17453b4155 (diff) | |
parent | 642f98c2ddd8af6c83d3de5a51c643ba93b23f96 (diff) | |
download | rest-query-46b354b6a49c0843fefc5794f2351f52b98102bd.tar.gz rest-query-46b354b6a49c0843fefc5794f2351f52b98102bd.tar.bz2 rest-query-46b354b6a49c0843fefc5794f2351f52b98102bd.zip |
Merge pull request #32 from drivergroup/PDSUI-rep-fixtures
Implemented generators of entities for ReP; Implemented json objects for swagger model
Diffstat (limited to 'src/main/scala/xyz/driver/pdsuidomain')
7 files changed, 499 insertions, 0 deletions
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() + ) + } +} |