Fixed generators of entities for ReP; Implemented json examples for swagger for ReP

6 files changed, 171 insertions, 66 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..f2c6d94 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,86 @@ 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
index fb1d3e3..e7cbd19 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/BridgeUploadQueueGen.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/BridgeUploadQueueGen.scala
@@ -2,30 +2,21 @@ 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.entities.ProviderType
-import xyz.driver.pdsuidomain.fakes.entities.common.{nextLocalDateTime, nextLongId}
+import xyz.driver.pdsuidomain.fakes.entities.common.nextLocalDateTime
 
 object BridgeUploadQueueGen {
-  private val maxAttemtsNumber = 100
+  private val maxAttemptsNumber = 100
 
   def nextBridgeUploadQueueItem(): BridgeUploadQueue.Item = {
     BridgeUploadQueue.Item(
       kind = nextString(),
       tag = nextString(),
       created = nextLocalDateTime,
-      attempts = nextInt(maxAttemtsNumber, minValue = 0),
+      attempts = nextInt(maxAttemptsNumber, minValue = 0),
       nextAttempt = nextLocalDateTime,
       completed = nextBoolean(),
       dependencyKind = nextOption(nextString()),
       dependencyTag = nextOption(nextString())
     )
   }
-
-  def nextProviderType(): ProviderType = {
-    ProviderType(
-      id = nextLongId[ProviderType],
-      name = nextString()
-    )
-  }
-
 }
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
index 2f07f1d..0d32495 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/DocumentGen.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/DocumentGen.scala
@@ -18,43 +18,47 @@ object DocumentGen {
     }
   }
 
-  private def nextDates =
+  private def nextDates() =
     Common.genBoundedRangeOption[LocalDate](nextLocalDate, nextLocalDate)
 
-  private def nextStartAndEndPagesOption =
+  private def nextStartAndEndPagesOption() =
     Common.nextStartAndEndPages
 
-  private def nextStartAndEndPage =
+  private def nextStartAndEndPage() =
     Common.genBoundedRange(nextDouble(),nextDouble())
 
 
-  def nextDocumentStatus: Document.Status =
-    generators.oneOf[Document.Status](Document.Status.All)
+  def nextDocumentStatus(): Document.Status =
+    Document.Status.New
 
-  def nextDocumentRequiredType: Document.RequiredType =
+  def nextDocumentRequiredType(): Document.RequiredType =
     generators.oneOf[Document.RequiredType](Document.RequiredType.All)
 
-  def nextDocumentHistoryState: DocumentHistory.State =
+  def nextDocumentHistoryState(): DocumentHistory.State =
     generators.oneOf[DocumentHistory.State](DocumentHistory.State.All)
 
-  def nextDocumentHistoryAction: DocumentHistory.Action =
+  def nextDocumentHistoryAction(): DocumentHistory.Action =
     generators.oneOf[DocumentHistory.Action](DocumentHistory.Action.All)
 
-  def nextDocumentMeta: Document.Meta = {
-    val (startPage, endPage) = nextStartAndEndPage
+  def nextDocumentMeta(): Document.Meta = {
+    val (startPage, endPage) = nextStartAndEndPage()
 
     Document.Meta(
       nextOption(nextBoolean()), startPage, endPage
     )
   }
 
-  def nextDocument: Document = {
-    val dates = nextDates
+  def nextDocumentMetaJson(): TextJson[Document.Meta] = {
+    TextJson(nextDocumentMeta())
+  }
+
+  def nextDocument(): Document = {
+    val dates = nextDates()
 
     Document(
       id = nextLongId[Document],
-      status = nextDocumentStatus,
-      previousStatus = nextOption(nextDocumentStatus),
+      status = nextDocumentStatus(),
+      previousStatus = None,
       assignee = nextOption(nextStringId[User]),
       previousAssignee = nextOption(nextStringId[User]),
       lastActiveUserId = nextOption(nextStringId[User]),
@@ -63,23 +67,23 @@ object DocumentGen {
       typeId = nextOption(nextLongId[DocumentType]),
       providerName = nextOption(nextString()),
       providerTypeId = nextOption(nextLongId[ProviderType]),
-      requiredType = nextOption(nextDocumentRequiredType),
-      meta = nextOption(TextJson(nextDocumentMeta)),
+      requiredType = nextOption(nextDocumentRequiredType()),
+      meta = nextOption(nextDocumentMetaJson()),
       startDate = dates._1,
       endDate = dates._2,
       lastUpdate = nextLocalDateTime
     )
   }
 
-  def nextDocumentType: DocumentType = {
+  def nextDocumentType(): DocumentType = {
     DocumentType(
       id = nextLongId[DocumentType],
       name = nextString()
     )
   }
 
-  def nextDocumentIssue(documentId: LongId[Document]): DocumentIssue = {
-    val pages = nextStartAndEndPagesOption
+  def nextDocumentIssue(documentId: LongId[Document] = nextLongId): DocumentIssue = {
+    val pages = nextStartAndEndPagesOption()
 
     DocumentIssue(
       id = nextLongId[DocumentIssue],
@@ -95,13 +99,13 @@ object DocumentGen {
   }
 
 
-  def nextDocumentHistory(documentId: LongId[Document]): DocumentHistory = {
+  def nextDocumentHistory(documentId: LongId[Document] = nextLongId): DocumentHistory = {
     DocumentHistory(
       id = nextLongId[DocumentHistory],
       executor = nextStringId[User],
       documentId = documentId,
-      state = nextDocumentHistoryState,
-      action = nextDocumentHistoryAction,
+      state = nextDocumentHistoryState(),
+      action = nextDocumentHistoryAction(),
       created = 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
index 512e324..0d99d19 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExtractedDataGen.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExtractedDataGen.scala
@@ -67,13 +67,23 @@ object ExtractedDataGen {
     )
   }
 
+  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(TextJson(nextExtractedDataMeta()))
+      meta = nextOption(nextExtractedDataMetaJson())
     )
   }
 
@@ -88,7 +98,7 @@ object ExtractedDataGen {
     )
   }
 
-  def nextRichExtractedData(documentId: LongId[Document]): RichExtractedData = {
+  def nextRichExtractedData(documentId: LongId[Document] = nextLongId): RichExtractedData = {
     RichExtractedData(
       extractedData = nextExtractedData(documentId),
       labels = List.fill(
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
index 0ea3cdd..90c98c3 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/MedicalRecordGen.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/MedicalRecordGen.scala
@@ -7,31 +7,31 @@ import xyz.driver.pdsuicommon.domain.{LongId, TextJson, User}
 import xyz.driver.pdsuidomain.fakes.entities.common.{nextLocalDateTime, nextLongId, nextStringId, nextUuidId}
 
 object MedicalRecordGen {
-  private val maxItemsInCollectionNumber = 50
+  private val maxItemsInCollectionNumber: Int = 50
 
-  private val pageMaxNumber = 1000
+  private val pageMaxNumber: Int = 1000
 
-  private val medicalRecordMetas = {
+  private val medicalRecordMetas: Set[() => MedicalRecord.Meta] = {
     Set(
-      () => nextMedicalRecordMetaReorder,
-      () => nextMedicalRecordMetaDuplicate,
-      () => nextMedicalRecordMetaRotation
+      () => nextMedicalRecordMetaReorder(),
+      () => nextMedicalRecordMetaDuplicate(),
+      () => nextMedicalRecordMetaRotation()
     )
   }
 
   def nextMedicalRecordMetas(count: Int): List[MedicalRecord.Meta] =
-    List.fill(count)(nextMedicalRecordMeta)
+    List.fill(count)(nextMedicalRecordMeta())
 
-  private def nextMedicalRecordMetasJson: TextJson[List[MedicalRecord.Meta]] =
+  def nextMedicalRecordMetasJson(): TextJson[List[MedicalRecord.Meta]] =
     TextJson(nextMedicalRecordMetas(nextInt(maxItemsInCollectionNumber, minValue = 0)))
 
-  private def nextDocument: Document =
-    DocumentGen.nextDocument
+  private def nextDocument(): Document =
+    DocumentGen.nextDocument()
 
   private def nextDocuments(count: Int): List[Document] =
-    List.fill(count)(nextDocument)
+    List.fill(count)(nextDocument())
 
-  private def nextDocuments(recordId: LongId[MedicalRecord]): TextJson[List[Document]] = {
+  def nextDocuments(recordId: LongId[MedicalRecord]): TextJson[List[Document]] = {
     val documents = nextDocuments(
       nextInt(maxItemsInCollectionNumber, minValue = 0)
     )
@@ -40,17 +40,17 @@ object MedicalRecordGen {
   }
 
 
-  def nextMedicalRecordStatus: MedicalRecord.Status =
-    generators.oneOf[MedicalRecord.Status](MedicalRecord.Status.All)
+  def nextMedicalRecordStatus(): MedicalRecord.Status =
+    MedicalRecord.Status.New
 
-  def nextMedicalRecordHistoryState: MedicalRecordHistory.State =
+  def nextMedicalRecordHistoryState(): MedicalRecordHistory.State =
     generators.oneOf[MedicalRecordHistory.State](MedicalRecordHistory.State.All)
 
-  def nextMedicalRecordHistoryAction: MedicalRecordHistory.Action =
+  def nextMedicalRecordHistoryAction(): MedicalRecordHistory.Action =
     generators.oneOf[MedicalRecordHistory.Action](MedicalRecordHistory.Action.All)
 
 
-  def nextMedicalRecordMetaReorder: MedicalRecord.Meta.Reorder = {
+  def nextMedicalRecordMetaReorder(): MedicalRecord.Meta.Reorder = {
     val itemsNumber =
       maxItemsInCollectionNumber
     val items = scala.util.Random
@@ -63,7 +63,7 @@ object MedicalRecordGen {
   }
 
 
-  def nextMedicalRecordMetaDuplicate: MedicalRecord.Meta.Duplicate = {
+  def nextMedicalRecordMetaDuplicate(): MedicalRecord.Meta.Duplicate = {
     val startPageGen =
       nextInt(pageMaxNumber, minValue = 0)
     val endPageGen =
@@ -78,7 +78,7 @@ object MedicalRecordGen {
     )
   }
 
-  def nextMedicalRecordMetaRotation: MedicalRecord.Meta.Rotation = {
+  def nextMedicalRecordMetaRotation(): MedicalRecord.Meta.Rotation = {
     val items =
       Array.tabulate(maxItemsInCollectionNumber)(
         index => nextString() -> index
@@ -90,7 +90,7 @@ object MedicalRecordGen {
     )
   }
 
-  def nextMedicalRecordMeta: MedicalRecord.Meta = {
+  def nextMedicalRecordMeta(): MedicalRecord.Meta = {
     generators.oneOf(medicalRecordMetas)()
   }
 
@@ -99,8 +99,8 @@ object MedicalRecordGen {
     val id = nextLongId[MedicalRecord]
     MedicalRecord(
       id = nextLongId[MedicalRecord],
-      status = nextMedicalRecordStatus,
-      previousStatus = nextOption(nextMedicalRecordStatus),
+      status = nextMedicalRecordStatus(),
+      previousStatus = None,
       assignee = nextOption(nextStringId),
       previousAssignee = nextOption(nextStringId),
       lastActiveUserId = nextOption(nextStringId),
@@ -109,8 +109,8 @@ object MedicalRecordGen {
       disease = generators.nextString(),
       caseId = nextOption(CaseId(generators.nextString())),
       physician = nextOption(generators.nextString()),
-      meta = nextOption(nextMedicalRecordMetasJson),
-      predictedMeta = nextOption(nextMedicalRecordMetasJson),
+      meta = nextOption(nextMedicalRecordMetasJson()),
+      predictedMeta = nextOption(nextMedicalRecordMetasJson()),
       predictedDocuments = nextOption(nextDocuments(id)),
       lastUpdate = nextLocalDateTime
     )
@@ -121,8 +121,8 @@ object MedicalRecordGen {
       id = nextLongId[MedicalRecordHistory],
       executor = nextStringId[User],
       recordId = nextLongId[MedicalRecord],
-      state = nextMedicalRecordHistoryState,
-      action = nextMedicalRecordHistoryAction,
+      state = nextMedicalRecordHistoryState(),
+      action = nextMedicalRecordHistoryAction(),
       created = nextLocalDateTime
     )
   }
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()
+    )
+  }
+}