1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
|
package xyz.driver.pdsuidomain.formats.json.extracteddata
import xyz.driver.pdsuicommon.domain.{LongId, TextJson}
import xyz.driver.pdsuidomain.entities.ExtractedData.Meta
import xyz.driver.pdsuidomain.entities._
import org.davidbild.tristate.Tristate
import org.davidbild.tristate.contrib.play.ToJsPathOpsFromJsPath
import play.api.data.validation._
import play.api.libs.functional.syntax._
import play.api.libs.json._
import xyz.driver.pdsuicommon.json.{JsonSerializer, JsonValidationException}
import xyz.driver.pdsuicommon.validation.{AdditionalConstraints, JsonValidationErrors}
import xyz.driver.pdsuidomain.formats.json.label.ApiExtractedDataLabel
import xyz.driver.pdsuidomain.services.ExtractedDataService.RichExtractedData
import scala.collection._
final case class ApiPartialExtractedData(documentId: Option[Long],
keywordId: Option[Long],
evidence: Tristate[String],
meta: Tristate[String],
labels: Tristate[List[ApiExtractedDataLabel]]) {
def applyTo(orig: RichExtractedData): RichExtractedData = RichExtractedData(
extractedData = applyTo(orig.extractedData),
labels = labels.cata(_.map(_.toDomain(orig.extractedData.id)), List.empty, orig.labels)
)
private def applyTo(orig: ExtractedData): ExtractedData = ExtractedData(
id = orig.id,
documentId = orig.documentId,
keywordId = keywordId.map(LongId[Keyword]).orElse(orig.keywordId),
evidenceText = evidence.cata(Some(_), None, orig.evidenceText),
meta = meta.map(x => TextJson(JsonSerializer.deserialize[Meta](x))).cata(Some(_), None, orig.meta)
)
def toDomain: RichExtractedData = {
val validation = Map(
JsPath \ "documentId" -> AdditionalConstraints.optionNonEmptyConstraint(documentId)
)
val validationErrors: JsonValidationErrors = validation.collect({
case (fieldName, e: Invalid) => (fieldName, e.errors)
})(breakOut)
if (validationErrors.isEmpty) {
val extractedData = ExtractedData(
documentId = documentId.map(LongId[Document]).get,
keywordId = keywordId.map(LongId[Keyword]),
evidenceText = evidence.toOption,
meta = meta.map(x => TextJson(JsonSerializer.deserialize[Meta](x))).toOption
)
val labelList = labels.map(_.map(_.toDomain()))
RichExtractedData(extractedData, labelList.getOrElse(List.empty))
} else {
throw new JsonValidationException(validationErrors)
}
}
}
object ApiPartialExtractedData {
private val reads: Reads[ApiPartialExtractedData] = (
(JsPath \ "documentId").readNullable[Long] and
(JsPath \ "keywordId").readNullable[Long] and
(JsPath \ "evidence").readTristate[String] and
(JsPath \ "meta").readTristate[String] and
(JsPath \ "labels").readTristate[List[ApiExtractedDataLabel]]
)(ApiPartialExtractedData.apply _)
private val writes: Writes[ApiPartialExtractedData] = (
(JsPath \ "documentId").writeNullable[Long] and
(JsPath \ "keywordId").writeNullable[Long] and
(JsPath \ "evidence").writeTristate[String] and
(JsPath \ "meta").writeTristate[String] and
(JsPath \ "labels").writeTristate[List[ApiExtractedDataLabel]]
)(unlift(ApiPartialExtractedData.unapply))
implicit val format: Format[ApiPartialExtractedData] = Format(reads, writes)
}
|
