Find the path of an JSON element with dynamic key with Play JSON

Question

I am using Play Framework with Scala. I have the following JSON structure:

{
    "a": 1540554574847,
    "b": 2,
    "c": {
    "pep3lpnp1n1ugmex5uevekg5k20wkfq3": {
    "a": 1,
    "b": 1,
    "c": 1,
    "d": 1
    },
    "p3zgudnf7tzqvt50g7lpr2ryno7yugmy": {
    "b": [
    "d10e5600d11e5517"
    ],
    "c": 1,
    "d": 1,
    "e": 1,
    "g": 1,
    "h": [
    "d10e5600d11e5517",
    "d10e5615d11e5527",
    "d10e5605d11e5520",
    "d10e5610d11e5523",
    "d10e5620d11e5530"
    ],
    "q": "a_z6smu56gstysjpqbzp21ruxii6g2ph00"
    },
    "33qfthhugr36f5ts4251glpqx0o373pe": {
    "b": [
    "d10e5633d11e5536"
    ],
    "c": 1,
    "d": 1,
    "e": 1,
    "g": 1,
    "h": [
    "d10e5638d11e5539",
    "d10e5633d11e5536",
    "d10e5643d11e5542",
    "d10e5653d11e5549",
    "d10e5648d11e5546"
    ],
    "q": "a_cydo6wu1ds340j3q6qxeig97thocttsp"
    }
    }
    }

I need to fetch values from paths "c" -> "pep3lpnp1n1ugmex5uevekg5k20wkfq3" -> "b", "c" -> "p3zgudnf7tzqvt50g7lpr2ryno7yugmy" -> "b", "c" -> "33qfthhugr36f5ts4251glpqx0o373pe" -> "b", and so on, where "pep3lpnp1n1ugmex5uevekg5k20wkfq3" is dynamic and changes for every JSON input.

Output should be like Seq(object(q,b,c)).

Answer 1

I misread the question, and this is the modified version.

Here I used json.pick to read JsObject and iterate the keys from there.

Ps: You don't have to create Reads or the case classes, but it should made the caller program more readable.

import play.api.libs.json.Json
import play.api.libs.json._

val jsonText =
  """{
    "top": {
      "level2a": {
        "a": 1,
        "b": 1,
        "c": 1,
        "d": 1
      },
      "level2b": {
        "a": 2,
        "b": 2,
        "nested": {
          "b": "not interested"
        }
      }
    }
  }"""

case class Data(k: String, v: Int)
case class Datas(list: Seq[Data])

object Datas {
  implicit val reads: Reads[Datas] = (__ \ "top").json.pick.map {
    case obj: JsObject =>
      new Datas(obj.keys.flatMap(k => (obj \ k \ "b").validate[Int] match {
        case JsSuccess(v, _) => Some(Data(k, v))
        case _ => None
      }).toSeq)
  }
}

Json.parse(jsonText).validate[Datas].asOpt match {
  case Some(d) => println(s"found: $d")
  case _ => println("not found")
}

---

To deserialize the internal structure within level2, you may choose to create the internal structure and use Json.reads to create the default reads. So long as the data structure is known and predictable.

For example

case class Internal(a: Int, b: Int, c: Option[Int], d: Option[Int])
object Internal {
  implicit val reads = Json.reads[Internal]
}
case class Data(k: String, v: Internal)
case class Datas(list: Seq[Data])
object Datas {
  implicit val reads: Reads[Datas] = (__ \ "top").json.pick.map {
    case obj: JsObject =>
      new Datas(obj.keys.flatMap(k => (obj \ k).validate[Internal].asOpt
        .map(v => Data(k, v))).toSeq)

  }
}

Answer 2

If you don't need to know which generated key belongs to which value you can use recursive path \\ operator:

import play.api.libs.json.Json
import play.api.libs.json._

val jsonText = """{
   "a":1540554574847,
   "b":2,
   "c":{
      "onegeneratedkey":{
         "a":1,
         "b":1,
         "c":1,
         "d":1
      },
      "secondsonegeneratedkey":{
         "a":1,
         "b": [1, 2, 3],
         "c":1,
         "d":1
      }
   }
}"""

val result: Seq[JsValue] = Json.parse(jsonText) \ "c" \\ "b"
// res: List(1, [1,2,3])

UPD.

To get all values stored inside object with generated-keys, one can use JsObject#values:

val valuesSeq: Seq[JsValue] = (Json.parse(jsonText) \ "c").toOption // get 'c' field
  .collect {case o: JsObject => o.values.toSeq} // get all object that corresponds to generated keys
  .getOrElse(Seq.empty)
// res: Seq({"a":1,"b":1,"c":1,"d":1}, {"a":1,"b":[1,2,3],"c":1,"d":1})

val valuesABC = valuesSeq.map(it => (it \ "a", it \ "b", it \ "c"))
// res: Seq((JsDefined(1),JsDefined(1),JsDefined(1)), (JsDefined(1),JsDefined([1,2,3]),JsDefined(1)))