播放：将案例类序列化为json的问题

Question

I'm implementing a REST API for which, in case of error, I want to send back a Json message like this:

{"errors":[
  {"timestamp":"14-Jan-2014 20:00:01","message":"Oops... error 1","code":1500}
  {"timestamp":"14-Jan-2014 20:01:04","message":"Oops... error 2","code":1503}
]}

Here below are my Writes :

import org.joda.time.DateTime
import play.api.libs.json._
import play.api.libs.functional.syntax._

class Error private(
  val timestamp: String,
  val message: String,
  val code: Int
) {
  override def hashCode = (timestamp + message + code).hashCode
}

object Error {

  def apply(message: String, code: Int) =
    new Error(DateTime.now.toString(""), message, code)

  def unapply(error: Error) = {
    if (error eq null) null
    else Some((
      error.timestamp,
      error.message,
      error.code
    ))
  }
}

case class Errors(dummy: String, errors: List[Error])

object Errors {

  val errorWrites: Writes[Error] = (
    (__ \ 'timestamp).write[String] ~
    (__ \ 'message).write[String] ~
    (__ \ 'code).write[Int]
  )(unlift(Error.unapply))

  implicit val errorsWrites: Writes[Errors] = (
    (__ \ 'errors).write[List[Error]](errorWrites)
  )(unlift(Errors.unapply))
}

The code above does not compile and I always get the following error:

[test] $ compile
[info] Compiling 1 Scala source to /home/j3d/Projects/test/target/scala-2.10/classes...
[error] /home/j3d/Projects/test/app/models/Errors.scala:88: overloaded method value write with alternatives:
[error]   (t: List[models.core.Error])(implicit w: play.api.libs.json.Writes[List[models.core.Error]])play.api.libs.json.OWrites[play.api.libs.json.JsValue] <and>
[error]   (implicit w: play.api.libs.json.Writes[List[models.core.Error]])play.api.libs.json.OWrites[List[models.core.Error]]
[error]  cannot be applied to (play.api.libs.json.Writes[models.core.Error])
[error]     (__ \ 'errors).write[List[Error]](errorWrites)
[error]                         ^
[error] one error found
[error] (core/compile:compile) Compilation failed
[error] Total time: 0 s, completed Jan 6, 2014 8:02:30 PM

Am I missing something?

Answer 1

Well, contramap works for me:

object Errors {

  implicit val errorWrites: Writes[Error] = (
    (__ \ 'timestamp).write[String] ~
    (__ \ 'message).write[String] ~
    (__ \ 'code).write[Int]
  )(unlift(Error.unapply))

  val foo: Writes[Errors] =  
    (__ \ 'errors).write[List[Error]].contramap( (e:Errors) => e.errors )

}

Direct approach also works:

implicit val errorsWrites = new Writes[Errors] {
  def writes(e: Errors): JsValue = {
    Json.obj(
        "errors" -> Json.toJson(e.errors)
    )
  }
}

And using Writes apply method:

implicit val errorsWrites2 = Writes[Errors] {(e:Errors) => 
    Json.obj("errors" -> Json.toJson(e.errors))
}

I haven't found the way to make play json functional builder accept just one value. But I think it is not critical, because above methods all work.

From the comments discussion, if you want to specify Writes[Error] explicitly for Errors, you should do it like this:

val listErrorWrites: Writes[List[Error]] = Writes { l : List[Error] =>
    Json.arr(l.map(Json.toJson(_)(errorWrites)))
  }

implicit val errorsWrites4: Writes[Errors] = (__ \ 'errors).write[List[Error]](listErrorWrites).contramap((e:Errors) => e.errors)