Scala OWrites类代码示例

//设置package包名称以及导入依赖的类
package models


import org.joda.time.{DateTime, Duration}
import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, Json, OWrites, Reads}

import scala.util.Random



case class OauthCode(code : String, user: User, client : OauthClient) {
  val created = new DateTime(new java.util.Date())

  // currently codes are valid for one day
  def isExpired : Boolean = created.plus(new Duration(24L*60L*60L*1000L)).isBeforeNow
}

object OauthCode {
  def apply(user: User, client: OauthClient) : OauthCode = OauthCode(Random.alphanumeric.take(100).mkString, user, client)
//  implicit val oauthCodeJsonFormat = Json.format[OauthCode]
  implicit val profileWrites : OWrites[OauthCode] = (
    (JsPath \ "code").write[String] and
      (JsPath \ "user").write[User] and
      (JsPath \ "client").write[OauthClient]
    )(unlift(OauthCode.unapply))
  implicit val profileReads : Reads[OauthCode] = (
    (JsPath \ "code").read[String] and
      (JsPath \ "user").read[User] and
      (JsPath \ "client").read[OauthClient]
    )((code, user, client) => OauthCode(code, user, client))
} 

//设置package包名称以及导入依赖的类
package models.response

import play.api.libs.json.{Json, OWrites, Reads}

sealed trait View {

}

object View {
  case class Gravity(x: Double, y: Double, z: Double, userId: Long, name: String) extends View
  case class Message(message: String, userId: Long, name: String) extends View
  case class Event(value: String, userId: Long, name: String) extends View

  trait JsonReader {
    implicit val testReader: Reads[Message] = Json.reads[Message]
  }
  trait JsonWriter {
    implicit val testWriter: OWrites[Message] = Json.writes[Message]
    implicit val eventWriter: OWrites[Event] = Json.writes[Event]
    implicit val gravityWriter = Json.writes[Gravity]
  }
} 

//设置package包名称以及导入依赖的类
package models.response

import play.api.libs.json.{JsValue, Json, OWrites, Reads}

sealed trait User {

}

case class Envelope(`type`: String,value: JsValue)

case class ChangeName(name: String) extends User
case class PressButton(value: String) extends User
case class ReleaseButton(value: String) extends User
case class SessionId(sessionId: Long) extends User
case class Gravity(x: Double, y: Double, z: Double) extends User
case class Test(message: String) extends User

trait JsonFormat {
  implicit val envelopeJsonRead: Reads[Envelope] = Json.reads[Envelope]

  implicit val sessionIdJsonRead: Reads[SessionId] = Json.reads[SessionId]
  implicit val sessionIdJsonWrite: OWrites[SessionId] = Json.writes[SessionId]
  implicit val gravityJsonRead: Reads[Gravity] = Json.reads[Gravity]
  implicit val testJsonWrite: OWrites[Test] = Json.writes[Test]
  implicit val testJsonRead: Reads[Test] = Json.reads[Test]
  implicit val changeNameJsonRead: Reads[ChangeName] = Json.reads[ChangeName]
  implicit val pressButtonJsonRead: Reads[PressButton] = Json.reads[PressButton]
  implicit val releaseButtonJsonRead: Reads[ReleaseButton] = Json.reads[ReleaseButton]
} 

//设置package包名称以及导入依赖的类
package controllers


import api.sharecare.events.aws.AWSConfigs
import com.google.inject.Inject
import com.sharecare.lib.play.phr.controllers.PHRController
import com.sharecare.lib.play.phr.queryparams.QueryParameters
import com.sharecare.lib.play.phr.repository.PHRRepository
import com.sharecare.sdk.sso.play.Auth
import com.sharecare.sdk.sso.play.models.{Maskable, SecureMask}
import model.{SocialConverters, SocialIn, SocialPersistence, SocialResponse}
import play.api.Configuration
import play.api.libs.json.{Json, OWrites, Reads}
import play.api.libs.ws.WSClient


class ServiceController  @Inject() (repo: PHRRepository[SocialIn, SocialPersistence, SocialResponse],
                                    auth: Auth,
                                    config: Configuration,
                                    awsConfig: AWSConfigs,
                                    ws: WSClient)
  extends PHRController[QueryParameters, SocialIn, SocialPersistence, SocialResponse](repo, auth, config, awsConfig, ws) {
  import com.sharecare.lib.play.phr.models.serialization.PhrFormats._
  import com.sharecare.lib.play.phr.controllers.ResultHelpers._
  import com.sharecare.lib.play.errors.serialization.ErrorJsonFormats._

  override implicit def P_Writes: OWrites[SocialIn] =  Json.writes[SocialIn]

  override implicit def R_Writes: OWrites[SocialResponse] = Json.writes[SocialResponse]

  override implicit def In_Reads: Reads[SocialIn] = Json.reads[SocialIn]

  override implicit def toPersistence(in: SocialIn): SocialPersistence = SocialConverters.toPersistence(in)

  override implicit def toResponse(in: SocialPersistence): SocialResponse = SocialConverters.toResponse(in)

  override implicit val ResponseMaskable: Maskable[SocialResponse] = new Maskable[SocialResponse] {
    override def applySecureMask(secureMask: SecureMask, accountPattern: String,
                                 output: SocialResponse): SocialResponse = {
      output.copy (
        userId   = SecureMask.idFromEntity(secureMask.entity, accountPattern, output.userId),
        secureId = if (secureMask.overrideSecureIdMask) output.secureId else secureMask.secureId
      )
    }
  }
  override val QP: (Map[String, Seq[String]]) => QueryParameters = QueryParameters.apply
} 

//设置package包名称以及导入依赖的类
package microtools.shapeless

import play.api.data.validation.ValidationError
import play.api.libs.json.{JsError, Json, OWrites, Reads}
import shapeless.{:+:, CNil, Coproduct, Generic, Inl, Inr, Lazy}

trait ShapelessAlgebraicEnum {
  implicit val cNilReads: Reads[CNil] = Reads[CNil](_ => JsError(ValidationError("error.invalid")))

  implicit val cNilWrites: OWrites[CNil] = OWrites[CNil](_ => Json.obj())

  implicit def coproductWrites[H, T <: Coproduct](
      implicit hWrites: Lazy[OWrites[H]],
      tWrites: OWrites[T],
      namingStrategy: NamingStrategy[H]
  ): OWrites[H :+: T] = OWrites[H :+: T] {
    case Inl(h) => hWrites.value.writes(h) ++ namingStrategy.nameFor(h)
    case Inr(t) => tWrites.writes(t)
  }

  implicit def coproductReads[H, T <: Coproduct](
      implicit hReads: Lazy[Reads[H]],
      tReads: Reads[T],
      namingStrategy: NamingStrategy[H]
  ): Reads[H :+: T] = Reads[H :+: T] {
    case json if namingStrategy.verify(json) => hReads.value.reads(json).map(h => Inl(h))
    case json                                => tReads.reads(json).map(t => Inr(t))
  }

  def deriveWrites[T, R](implicit gen: Generic.Aux[T, R], writes: Lazy[OWrites[R]]): OWrites[T] =
    OWrites[T] { obj =>
      writes.value.writes(gen.to(obj))
    }

  def deriveReads[T, R](implicit gen: Generic.Aux[T, R], reads: Lazy[Reads[R]]): Reads[T] =
    reads.value.map(gen.from)

}

object ShapelessAlgebraicEnum extends ShapelessAlgebraicEnum 

//设置package包名称以及导入依赖的类
package lila.common

import lila.common.PimpedJson._
import play.api.libs.json.{ Json, OWrites }

case class LightUser(
    id: String,
    name: String,
    title: Option[String],
    isPatron: Boolean
) {

  def titleName = title.fold(name)(_ + " " + name)
  def titleNameHtml = title.fold(name)(_ + " " + name)
}

object LightUser {

  implicit val lightUserWrites = OWrites[LightUser] { u =>
    Json.obj(
      "id" -> u.id,
      "name" -> u.name,
      "title" -> u.title,
      "patron" -> u.isPatron
    ).noNull
  }

  type Getter = String => Fu[Option[LightUser]]
  type GetterSync = String => Option[LightUser]
} 

//设置package包名称以及导入依赖的类
package controllers

import javax.inject.Singleton

import akka.actor.ActorSystem
import akka.stream.Materializer
import com.google.inject.Inject
import helpers.MongoDB
import models.UserManager
import models.commons.MongoCollectionNames._
import play.api.Configuration
import play.api.libs.json.{OWrites, Reads}
import play.modules.reactivemongo.ReactiveMongoApi
import reactivemongo.play.json.collection.JSONCollection

import scala.concurrent.{ExecutionContext, Future}


@Singleton
class UserManagerController @Inject() (override val reactiveMongoApi: ReactiveMongoApi)
                                      (implicit executionContext: ExecutionContext,
                                       configuration: Configuration,
                                       system: ActorSystem,
                                       materializer: Materializer)
  extends CommonController(reactiveMongoApi) {

  override type P = UserManager
  override implicit val mainCollection: Future[JSONCollection] = getJSONCollection(UserManagers)
  MongoDB.dbs.put(UserManagers,mainCollection)
  override implicit val mainReader: Reads[UserManager] = UserManager.userManagerReader
  override implicit val mainWriter: OWrites[UserManager] = UserManager.userManagerWrites

} 

//设置package包名称以及导入依赖的类
package controllers

import javax.inject.Singleton

import akka.actor.ActorSystem
import akka.stream.Materializer
import com.google.inject.Inject
import helpers.MongoDB
import models.TaskManager
import models.commons.MongoCollectionNames._
import play.api.Configuration
import play.api.libs.json.{OWrites, Reads}
import play.modules.reactivemongo.ReactiveMongoApi
import reactivemongo.play.json.collection.JSONCollection

import scala.concurrent.{ExecutionContext, Future}


@Singleton
class TaskManagerController @Inject()(override val reactiveMongoApi: ReactiveMongoApi)
                                     (implicit executionContext: ExecutionContext,
                                      configuration: Configuration,
                                      system: ActorSystem,
                                      materializer: Materializer)
  extends CommonController(reactiveMongoApi) {

  override type P = TaskManager
  override implicit val mainCollection: Future[JSONCollection] = getJSONCollection(TaskManagers)
  MongoDB.dbs.put(TaskManagers, mainCollection)
  override implicit val mainReader: Reads[TaskManager] = TaskManager.taskManagerReader
  override implicit val mainWriter: OWrites[TaskManager] = TaskManager.taskManagerWrites

} 

//设置package包名称以及导入依赖的类
package models.config

import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, OWrites, Reads}

case class PhilipsScene(
  name: String,
  lights: Seq[String],
  colors: Seq[String],
  default: Boolean)

object PhilipsScene {

  implicit val reads: Reads[PhilipsScene] = (
    (JsPath \ "name").read[String] and
    (JsPath \ "lights").read[Seq[String]] and
    (JsPath \ "colors").read[Seq[String]] and
    (JsPath \ "default").read[Boolean]
  )((name, lights, colors, default) => PhilipsScene.apply(name, lights, colors, default))

  implicit val writes: OWrites[PhilipsScene] = (
    (JsPath \ "name").write[String] and
    (JsPath \ "lights").write[Seq[String]] and
    (JsPath \ "colors").write[Seq[String]] and
    (JsPath \ "default").write[Boolean]
  )(scene => (scene.name.toLowerCase(), scene.lights, scene.colors, scene.default))
} 

//设置package包名称以及导入依赖的类
package models.config

import play.api.libs.functional.syntax.unlift
import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, OWrites, Reads}
import services.virtual_switch.{VirtualDevice, VirtualService}

case class VirtualConf private(
    id: Int,
    name: String,
    devices: Seq[VirtualDevice]) extends DomoConfiguration(id, name)

object VirtualConf {

  def apply(devices: Seq[VirtualDevice]) =
    new VirtualConf(VirtualService.serviceId, VirtualService.serviceName, devices)

  implicit val reads: Reads[VirtualConf] = (
    (JsPath \ "id").read[Int] and
    (JsPath \ "name").read[String] and
    (JsPath \ "devices").read[Seq[VirtualDevice]]
  )((id, name, devices) => VirtualConf.apply(devices))

  implicit val writes: OWrites[VirtualConf] = (
    (JsPath \ "id").write[Int] and
    (JsPath \ "name").write[String] and
    (JsPath \ "devices").write[Seq[VirtualDevice]]
  )(unlift(VirtualConf.unapply))
} 

//设置package包名称以及导入依赖的类
package services.virtual_switch

import play.api.libs.functional.syntax._
import play.api.libs.json.{JsPath, OWrites, Reads}

case class VirtualDevice(
    id: String,
    name: String,
    alias: Option[String],
    switches: Seq[SwitchMapping]) {

  def setAlias(value: String): VirtualDevice = copy(alias = Some(value))
}

object VirtualDevice {

  implicit val reads: Reads[VirtualDevice] = (
    (JsPath \ "id").read[String] and
    (JsPath \ "name").read[String] and
    (JsPath \ "alias").readNullable[String] and
    (JsPath \ "switches").read[Seq[SwitchMapping]]
  )(VirtualDevice.apply _)

  implicit val writes: OWrites[VirtualDevice] = (
    (JsPath \ "id").write[String] and
    (JsPath \ "name").write[String] and
    (JsPath \ "alias").writeNullable[String] and
    (JsPath \ "switches").write[Seq[SwitchMapping]]
  )(unlift(VirtualDevice.unapply))
} 

//设置package包名称以及导入依赖的类
package models

import play.api.data._
import play.api.data.Forms.{mapping, _}
import play.api.libs.json.{Json, OWrites}

case class SessionType(
  id: Int,
  name: String,
  points: Seq[Int],
  incidentsLimit: Int,
  penaltyPoints: Int
) {}

object SessionType {

  implicit val writes: OWrites[SessionType] = Json.writes[SessionType]

  def getMappingWithMandatoryId() : Mapping[SessionType] = {
    mapping(
      "id" -> number,
      "name" -> nonEmptyText,
      "points" -> seq(number),
      "incidentsLimit" -> number,
      "penaltyPoints" -> number
    )(SessionType.apply)(SessionType.unapply)
  }

  def getMapping() = mapping(
    "id" -> number,
    "name" -> nonEmptyText,
    "points" -> seq(number),
    "incidentsLimit" -> number,
    "penaltyPoints" -> number
  )(SessionType.apply)(SessionType.unapply)

  val form: Form[SessionType] = Form(
    getMapping()
  )
} 

//设置package包名称以及导入依赖的类
package models

import play.api.data._
import play.api.data.Forms._
import play.api.libs.json.{Json, OWrites}

case class Session(
  id: Int,
  name: String,
  date: String,
  time: String,
  track: Track,
  sessionType: SessionType
) {}

object Session {

  implicit val sessionWrites: OWrites[Session] = Json.writes[Session]

  def getMapping() : Mapping[Session] = mapping(
    "id" -> ignored(0),
    "name" -> text,
    "date" -> text,
    "time" -> text,
    "track" -> Track.getMappingWithMandatoryId(),
    "sessionType" -> SessionType.getMappingWithMandatoryId()
  )(Session.apply)(Session.unapply)

  val form: Form[Session] = Form(getMapping())

} 

//设置package包名称以及导入依赖的类
package models

import play.api.data._
import play.api.data.Forms._
import play.api.libs.json.{Json, OWrites}

case class Championship(
  id: Int = 0,
  name: String,
  description: Option[String],
  thumbnailUrl: Option[String]
) {}

object Championship {

  implicit val configWrites: OWrites[Championship] = Json.writes[Championship]

  val form: Form[Championship] = Form(
    mapping(
      "id" -> ignored(0),
      "name" -> nonEmptyText,
      "description" -> optional(text),
      "thumbnailUrl" -> optional(text)
    )(Championship.apply)(Championship.unapply)
  )

} 

//设置package包名称以及导入依赖的类
package models

import play.api.data._
import play.api.data.Forms._
import play.api.libs.json.{Json, OWrites}

case class ChampionshipConfiguration(
  sessionTypes: Seq[SessionType],
  subClasses: Option[Seq[String]]
) { }

object ChampionshipConfiguration {

  implicit val writes: OWrites[ChampionshipConfiguration] = Json.writes[ChampionshipConfiguration]

  val form: Form[ChampionshipConfiguration] = Form(
    mapping(
      "sessionTypes" -> seq(SessionType.getMapping()),
      "subClasses" -> optional(seq(text))
    )(ChampionshipConfiguration.apply)(ChampionshipConfiguration.unapply)
  )
}