General discussion of Play: https://www.playframework.com/ | Code of Conduct: https://www.lightbend.com/conduct | Forums: https://discuss.playframework.com | Commercial support from https://www.lightbend.com/
I'm to update a JSON formatter in my Play app to support multiple legacy formats, and would like to find a less redundant solution.
Below is a simplistic example of what I am doing. I've changed the name of one of the case class arguments, and have built an OFormat to support reading JSON for the old and new format, and writing only in the new format.
The problem is that this solution requires duplication of the parsing logic for all unchanged case class arguments (in my actual situation, there are more arguments, more than one legacy format, and more complex parsing operations).
Is there a better way to do this to avoid the duplicated parsing logic?
case class Simple(rank: String, desc: String, code: String)
object Simple {
private val readsOrig: Reads[Simple] = (
(JsPath \ "title").read[String] and
(JsPath \ "desc").read[String](minLength[String](5)) and
(JsPath \ "code").read[String](minLength[String](3))
)(Simple(_,_,_))
private val readsCurr: Reads[Simple] = (
(JsPath \ "rank").read[String] and
(JsPath \ "desc").read[String](minLength[String](5)) and
(JsPath \ "code").read[String](minLength[String](3))
)(Simple(_,_,_))
private implicit val format: OFormat[Simple] = OFormat[Simple](
new Reads[Simple]{override def reads(js: JsValue): JsResult[Simple] = {
readsCurr.reads(js) match {
case s: JsSuccess[Simple] => s
case _ => readsOrig.reads(js)
}
}},
Json.writes[Simple] // write in the current supported format
)
or combinator: object Simple {
implicit val format: OFormat[Simple] = OFormat[Simple](
(((JsPath \ "rank").read[String] or (JsPath \ "title").read[String]) and
(JsPath \ "desc").read[String](minLength[String](5)) and
(JsPath \ "code").read[String](minLength[String](3))
)(Simple(_, _, _)),
Json.writes[Simple] // write in the current supported format
)
}
application.conf are defined? Interested in seeing a list of all config options and their default values -- e.g. play.http.parser.maxDiskBuffer has a default value of 10MB, but I only discovered that reading through body parsers documentation. Remember seeing a central defaults config file somewhere but it was a couple of years ago.
@TimMoore
@natonic77 you can use an
orcombinator:
...
This was a great solution for my basic case, but since "and" returns a FunctionalBuilder instead of a Reads, I can't do a more complex case where a group of changes belongs together (say I renamed desc and code to newDesc and newCode).
object Simple {
implicit val format: OFormat[Simple] = OFormat[Simple](
(((JsPath \ "rank").read[String] or (JsPath \ "title").read[String]) and
((JsPath \ "desc").read[String](minLength[String](5)) and
(JsPath \ "code").read[String](minLength[String](3)))
or
((JsPath \ "newDesc").read[String](minLength[String](5)) and
(JsPath \ "newCode").read[String](minLength[String](3)))
)(Simple(_, _, _)),
Json.writes[Simple] // write in the current supported format
)
}...wouldn't work.
The following approach would work, and I may have to use it, but it doesn't allow bundling the changes together (it would allow for "newDesc" coupled with "code" in a single JSON string for instance):
object Simple {
implicit val format: OFormat[Simple] = OFormat[Simple](
(((JsPath \ "rank").read[String] or (JsPath \ "title").read[String]) and
((JsPath \ "desc").read[String](minLength[String](5)) or (JsPath \ "newDesc").read[String](minLength[String](5))) and
((JsPath \ "code").read[String](minLength[String](3)) or (JsPath \ "newCode").read[String](minLength[String](3)))
)(Simple(_, _, _)),
Json.writes[Simple] // write in the current supported format
)
}Any ideas? I feel like I might be asking for more flexibility than the combinators are designed to provide.
{
case class Foo(accountNumber: String)
object Foo {
implicit val config = JsonConfiguration(SnakeCase)
import ai.x.play.json.Jsonx
implicit lazy val jsonFormat = Jsonx.formatCaseClass[Foo]
}
}
Json.parse("""{"account_number":"a"}""").validate[Foo]JsError( List((JsPath(List(KeyPathNode("accountNumber"))), List(JsonValidationError(List("error.path.missing"), WrappedArray())))) )
final case class Simple(rank: String, code: String, desc: String)
object Simple {
import play.api.libs.json._
import play.api.libs.functional.syntax._
implicit val writes: OWrites[Simple] = (
(__ \ "rank").write[String] and
(__ \ "code").write[String] and
(__ \ "desc").write[String]
)(unlift(Simple.unapply))
implicit val reads: Reads[Simple] = {
val oldReads: Reads[Simple] = (
(__ \ "rank").read[String] and
(__ \ "code").read[String] and
(__ \ "desc").read[String]
)(Simple(_, _, _))
val newReads = (
(__ \ "rank").read[String] and
(__ \ "newCode").read[String] and
(__ \ "newDesc").read[String]
)(Simple(_, _, _))
newReads orElse oldReads
}
}OFormat as long as you have a Reads and OWrites separating out their definitions can make things like this a bit cleaner and easier to represent.
What are the differences between an akka actor vs java thread
Lot of people shows interest about Akka framework, but so far have not seen many actual examples of use cases it would be good for.
So I would be interested in hearing about things developers have used it successfully.
Also, i found it difficult in understanding any snippet
Can anyone shows a simple example to show how Akka works and makes the difference.
Does Default Java features misses things and has been achieved via Akka ??
multi threading with Executor Service vs Using Akka
Does actors was very good and faster than executor service threads.
Why people are moving to Actors when java executor service is good
final case class Simple(rank: String, somethingElse: String, code: String, desc: String)
object Simple {
import play.api.libs.json._
import play.api.libs.functional.syntax._
implicit val writes: OWrites[Simple] = (
(__ \ "rank").write[String] and
(__ \ "somethingElse").write[String] and
(__ \ "code").write[String] and
(__ \ "desc").write[String]
)(unlift(Simple.unapply))
implicit val reads: Reads[Simple] = {
val commonFields =
(__ \ "rank").read[String] and
(__ \ "somethingElse").read[String]
val oldReads: Reads[Simple] = (
commonFields and
(__ \ "code").read[String] and
(__ \ "desc").read[String]
)(Simple(_, _, _, _))
val newReads = (
commonFields and
(__ \ "newCode").read[String] and
(__ \ "newDesc").read[String]
)(Simple(_, _, _, _))
newReads orElse oldReads
}
}
I found official doc, and understood howto use HandlerDef. getModifiers();
resolved.
https://www.playframework.com/documentation/2.7.x/Highlights26#Route-modifier-tags
@wolfendale, that is exactly what I tried before my initial post, but I ran into trouble getting it to compile. I thought it was because I couldn't combine commonFields with other .read calls, but your reply inspired me to take another look, and I realized it had nothing to do with the 'and'.
My problem stemmed from the fact that my format changes were not sequential fields and not at the beginning or end. I was using invalid syntax to apply the Reads to my object with explicitly named parameters. For example, in a case where "code" was after "rank" in the Simple case class signature, I was trying to do this:
val newReads = (
commonFields and
(__ \ "newCode").read[String] and
(__ \ "newDesc").read[String]
)(Simple(rank=_, somethingElse=_, code=_, desc=_))when I should have been doing this:
val newReads = (
commonFields and
(__ \ "newCode").read[String] and
(__ \ "newDesc").read[String]
)((rank,somethingElse,code,desc) => Simple(rank, code,somethingElse,desc))My scala-fu is still weak. Anyway, the corrected syntax for applying the Reads parameters explicitly (as in the second example) solved my problem.
Thanks a ton for writing back in.
val oldReads: Reads[Simple] = (
commonFields and
(__ \ "code").read[String] and
(__ \ "desc").read[String]
)((rank, somethingElse, code, desc) => Simple(rank, somethingElse, code, desc))
