spray-json.scala

package org.zalando.nakadi.client

import scala.concurrent.duration.DurationInt

import org.slf4j.LoggerFactory
import org.zalando.nakadi.client.model.EventMetadata

object Main extends App {
  val logger = LoggerFactory.getLogger(this.getClass)
  val host = "nakadi-sandbox.aruha-test.zalan.do"
  val OAuth2Token = () => "aaaaa-a-a-a-aaaa"
  val port = 443

  //  val client = new ClientImpl(Connection.newConnection(host, port, OAuth2Token, true, false), "UTF-8")

  //  Await.result(client.partitionStrategies(), 10.second) match {
  //    case Left(error)=> logger.info("################## error:"+error.msg) 
  //    case Right(None)=> logger.info("################# Result is empty") 
  //    case Right(Some(result))=> logger.info("################# Result : "+result) 
  //  }

  //  client.stop()

  import spray.json._
  import DefaultJsonProtocol._

//  case class Example1(name: String,
//                      metadata: EventMetadata) extends Event {
//    def label() = ""
//  }

//  case class DataChangeEvent[T](
//      data: T,
//      dataType: String,
//      metadata: EventMetadata) extends Event {
//    def label() = "data-change-event"
//  }

//  abstract class DataChangeEventQualifier {
//    def dataType(): String
//  }
//  implicit val eventMetadataFormatter = jsonFormat(EventMetadata, "eid")
//  implicit val exampleFormatter = jsonFormat(Example1, "name", "metadata")
//  implicit def dataChangeEventFormatter[A: JsonFormat] = jsonFormat(DataChangeEvent.apply[A], "data", "data_type", "metadata")

  

  // EXAMPLE 1

  //  val example = new Example1("fernando", metadata)
  //  val dataChangeEvent = new DataChangeEvent[Example1](example, "json", metadata)
  //
  //  println(" >>> " + dataChangeEvent)
  //  var example1Result = dataChangeEvent.toJson.convertTo[DataChangeEvent[Example1]]
  //  println(" >>> " + example1Result)
  //
  //  // EXAMPLE 2
  //
  //  case class Example2[T](name: String, event: T, metadata: EventMetadata) extends Event {
  //    def label(): String = "example2"
  //  }
  //  implicit def example2Formatter[A: JsonFormat] = jsonFormat(Example2.apply[A], "name", "event", "metadata")
  //
  //  val example2 = new Example2[DataChangeEvent[Example1]]("fernando", dataChangeEvent, metadata)
  //  val jsonExample2 = example2.toJson
  //  println(" Model = " + example2)
  //  println(" Json = " + jsonExample2)
  //  var example2Result = jsonExample2.convertTo[Example2[DataChangeEvent[Example1]]]
  //  println("Model = " + example2Result)

  // EXAMPLE 3
  //  case class Example3(name: String, event: Seq[Event], metadata: EventMetadata) extends Event{
  //    def label() = "example3"
  //  }
  //  implicit def example3Formatter = jsonFormat(Example3.apply, "name", "event", "metadata")
  //  implicit def eventFormatter[T](implicit fmt:JsonFormat[T]) = new RootJsonFormat[Event]{
  //    def write(model:Event) =  model match {
  //      case a:Example3 => fmt.write(obj)
  //    }
  //    def read(in:JsValue) = ???
  //  }


  trait Event {
    def metadata(): EventMetadata
    def label(): String
  }

  case class EventMetadata(eid: String)
  
  case class BusinessEvent(name: String, metadata: EventMetadata) extends Event {
    def label(): String = "business"
  }

  case class DataChangeEvent(name: String, metadata: EventMetadata, event:Event ) extends Event {
    def label(): String = "change-event"
  }

  
  val metadata = EventMetadata("eid")
  
  implicit val eventMetadataFormatter = jsonFormat(EventMetadata, "eid")
  implicit val businessEventFormatter = jsonFormat(BusinessEvent, "name", "metadata")
  

  implicit object AnimalJsonFormat extends RootJsonFormat[Event] {
    def write(a: Event) = a match {
      case p: BusinessEvent => p.toJson
    }
    def read(json: JsValue) = json.asJsObject.fields("label") match {
      case JsString("business")     => json.convertTo[BusinessEvent]
      case JsString("change-event") => json.convertTo[DataChangeEvent]
      case _ =>
        throw new IllegalStateException("Couldn't parse what seems to be an Event: %s".format(json))
    }
  }
  implicit val dataChangeEventFormatter:JsonFormat[DataChangeEvent] = jsonFormat(DataChangeEvent, "name", "metadata","event")

}