Play Json - Complex object creation - json

Question

I'm trying to create Json readers in my Play framework application (Scala). The problem is, part of my Json is a little funky, and requires further processing to retrieve the values. For example:
{
"field1":"value1",
"field2":"value/1",
"num2":2
}
with case classes:
case class Field1(text: String, fields: Field2)
case class Field2(text: String, num: Int, num2: Int)
Basically the text and num fields for Field2 are derived from the value value/1, by splitting the text. Here's the splitter function:
def splitter(path: String, num2: Int): Field2 = {
val split = path.split("\\")
Field2(split(0), split(1).toInt, num2)
}
This is fairly straightforward, the actual splitter function is far more complex. Basically the only way to construct this object Field2 is to pass a single string to a function that spits out the required object.
How do I go about creating a reader for Field2 (and by extension for Field1)?
Here's what I have so far:
object Field1 {
implicit val reader = (
(__ \ "field1").read[String] and
(__).read[Field2]
) (Field1.apply _)
}
object Field2 {
implicit val reader = (
splitter((__ \ "field2").read[String], (__ \ "num2"))
) // Obviously incorrect syntax + type mismatch, but this is roughly what I'm trying to accomplish.
}

Answer 1

If you use the non-functional combinator syntax it becomes a little simpler I think:
object Field2 {
implicit val reader = Reads[Field2] { json =>
for {
path <- (json \ "field2").validate[String]
num2 <- (json \ "num2").validate[Int]
} yield splitter(path, num2)
}
}
Additionally if you want splitter to further validate the input have it return a JsResult[Field2] like this:
def splitter(path: String, num2: Int): JsResult[Field2] = {
val split = path.split("\\")
if (split.size != 2) {
JsError(s"$path must be of the form: {field}\\{num}")
} else {
Try(Field2(split(0), split(1).toInt, num2)).map(JsSuccess(_)).getOrElse {
JsError(s"${split(1)} is not a valid Int")
}
}
}
And then modify the reader:
object Field2 {
implicit val reader = Reads[Field2] { json =>
for {
path <- (json \ "field2").validate[String]
num2 <- (json \ "num2").validate[Int]
field2 <- splitter(path, num2)
} yield field2
}
}
If you still prefer using the functional syntax and you don't mind the lack of validation that splitter does try this:
def splitter(path: String, num2: Int): Field2 = {
val split = path.split("\\")
Field2(split(0), split(1).toInt, num2)
}
implicit val reader = (
(__ \ "field2").read[String] and
(__ \ "num2").read[Int]
)(splitter _)
I'd recommend against this, it's unsafe (split(1) and toInt both might throw exceptions) and the functional syntax can have performance issues. See https://www.lucidchart.com/techblog/2016/08/29/speeding-up-restful-services-in-play-framework/.

Answer 2

I don't know why do you need case classes, but you can also transform json for your needs with
(__ \ "field2" \ "num2").json.copyFrom((__ \ "num2").json.pick) and
(__ \ "field2").json.update(
of[String].map { o =>
val split = o.split("/")
Json.obj(
"text" -> split(0),
"num" -> split(1).toInt
)
}
)
).reduce andThen (__ \ "num2").json.prune
scala> j: play.api.libs.json.JsResult[play.api.libs.json.JsObject] = JsSuccess({"field2":{"num2":2,"text":"value","num":1},"field1":"value1"},/num2)
and then you can use your Reads[Field1]