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

import java.util.UUID
import javax.inject.{Inject, Singleton}

import models.RestResource
import play.api.libs.json.{JsError, JsValue, Json}
import play.api.mvc._

import scala.concurrent.Future

@Singleton
class ApiController @Inject()(cc: ControllerComponents) extends AbstractController(cc) {

  def index: Action[AnyContent] = {
    val resources = Seq(RestResource(UUID.randomUUID(), "name 1", "link 2"),
                        RestResource(UUID.randomUUID(), "name 2", "link 2"))
    Action.async {
      val json = Json.toJson(resources)
      Future.successful(Ok(json))
    }
  }

  def show(id: UUID): Action[AnyContent] = {
    Action.async {
      implicit request =>
        val json = Json.toJson(RestResource(id, "name x", "link x"))
        Future.successful(Ok(json))
    }
  }

  def process: Action[JsValue] = Action(parse.json) { implicit request =>
    request.body.validate[RestResource]
      .fold(
        errors =>
          BadRequest(Json.obj("status" -> "KO", "message" -> JsError.toJson(errors))),
        restResource => {
          println(restResource)
          Ok(Json.toJson(restResource))
        }
      )
  }

  def delete(id: String) = ???

  def update(id: String) = ???

} 

//设置package包名称以及导入依赖的类
package auth.http.service.impl.authorization.impl

import auth.core.model.core.{Permission, PermissionToUser, User}
import auth.core.service.authorization.{PermissionAuthorization, PermissionsAuthorizer}
import com.mohiva.play.silhouette.impl.authenticators.JWTAuthenticator
import play.api.Configuration
import play.api.libs.json.{JsError, JsSuccess}
import play.api.libs.ws.WSClient
import play.api.mvc.Request

import scala.concurrent.{ExecutionContext, Future}
import play.api.Logger


class PermissionsViaHttpAuthorizer(configuration: Configuration, ws: WSClient)(
    implicit ec: ExecutionContext)
    extends PermissionsAuthorizer {
  import auth.core.formatting.core.Rest._

  private val logger   = Logger(this.getClass)
  private val endpoint = configuration.underlying.getString("auth.http.user-service.url")
  private def uri(uuid: String): String = s"$endpoint/users/$uuid/permissions"

  override def require(required: Permission): PermissionAuthorization[JWTAuthenticator] =
    new PermissionAuthorization[JWTAuthenticator] {
      override def isAuthorized[B](identity: User, authenticator: JWTAuthenticator)(
          implicit request: Request[B]): Future[Boolean] = {
        val endpoint = uri(identity.uuid.toString)

        val f = ws.url(endpoint).get().map { resp ?
          val permissions = resp.json.validate[Seq[PermissionToUser]]
          permissions match {
            case JsSuccess(ps, _) ?
              ps.map(_.permission).contains(required)
            case JsError(e) ?
              logger.error(e.mkString("\n"))
              false
          }
        }
        logError(f, endpoint)
        f
      }
    }

  @inline private def logError[A](f: Future[_], endpoint: String): Unit =
    f.onFailure {
      case e: Throwable ?
        logger.error(s"Error during request to $endpoint", e)
    }
} 

//设置package包名称以及导入依赖的类
package akka.http.documenteddsl

import akka.http.scaladsl.marshallers.playjson.PlayJsonSupport.PlayJsonError
import akka.http.scaladsl.model.MediaTypes.`application/json`
import akka.http.scaladsl.server.{RejectionError, ValidationRejection}
import akka.http.scaladsl.unmarshalling.{FromEntityUnmarshaller, FromStringUnmarshaller, Unmarshaller}
import akka.util.ByteString
import play.api.libs.json.{JsError, JsValue, Json, Reads}

class PreprocessedFromStringUnmarshaller[T](sanitize: Preprocess[String], _fsu: FromStringUnmarshaller[T]) {
  implicit val fsu: FromStringUnmarshaller[T] = Unmarshaller withMaterializer {
    implicit ec =>
      implicit mat =>
        string =>
          _fsu(sanitize(string))
  }
}

object PreprocessedFromStringUnmarshaller {
  implicit def unmarshaller[T](implicit sanitize: Preprocess[String] = Preprocess.identity, fsu: FromStringUnmarshaller[T]): PreprocessedFromStringUnmarshaller[T] = {
    new PreprocessedFromStringUnmarshaller(sanitize, fsu)
  }
}

class PreprocessedFromEntityUnmarshaller[T](sanitize: Preprocess[JsValue], reads: Reads[T]) {
  private val jsonStringUnmarshaller =
    Unmarshaller.byteStringUnmarshaller
      .forContentTypes(`application/json`)
      .mapWithCharset {
        case (ByteString.empty, _) => throw Unmarshaller.NoContentException
        case (data, charset)       => data.decodeString(charset.nioCharset.name)
      }

  implicit val fsu: FromEntityUnmarshaller[T] = jsonStringUnmarshaller map { data =>
    val json = sanitize(Json parse data)

    reads reads json recoverTotal { error =>
      throw RejectionError(ValidationRejection(JsError.toJson(error).toString, Some(PlayJsonError(error))))
    }
  }
}

object PreprocessedFromEntityUnmarshaller {
  implicit def unmarshaller[T](implicit sanitize: Preprocess[JsValue] = Preprocess.identity, reads: Reads[T]): PreprocessedFromEntityUnmarshaller[T] = {
    new PreprocessedFromEntityUnmarshaller(sanitize, reads)
  }
}

trait Preprocess[T] {
  def apply(x: T): T
}
object Preprocess {
  def identity[T]: Preprocess[T] = new Preprocess[T] {
    override def apply(x: T): T = x
  }
} 

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

import java.util.UUID
import javax.inject.Inject

import models.Account
import pdi.jwt.{JwtAlgorithm, JwtJson}
import play.api.libs.json.{JsError, JsSuccess, Json}
import play.api.mvc._
import repositories.AccountRepository
import utils.{Conf, Log}

import scala.concurrent.Future
import scala.util.{Failure, Success}

case class AuthenticatedRequest[A](account: Account, request: Request[A]) extends WrappedRequest[A](request)

class AuthenticationActionService @Inject()(conf: Conf, accountRepository: AccountRepository) extends Log {
  val key = conf.cryptoKey

  object AuthenticatedAction extends ActionBuilder[AuthenticatedRequest] {
    override def invokeBlock[A](request: Request[A], block: (AuthenticatedRequest[A]) => Future[Result]): Future[Result] = {
      val errorResponse = Json.obj("error" -> "Unauthorized")
      request.headers.get("Authorization")
      .orElse(request.getQueryString("token"))
      .orElse(request.cookies.get("token").map(_.value))
      .orElse(request.session.get("token")) match {
        case Some(token) =>
          logger.debug(s"${request.toString()} Authorization=$token")
          JwtJson.decodeJson(token, key, Seq(JwtAlgorithm.HS256)) match {
            case Success(json) =>
              (json \ "user_id").validate[UUID] match {
                case s: JsSuccess[UUID] =>
                  accountRepository.getByUUID(s.get) match {
                  case Some(user) =>
                    logger.debug(s"${request.toString()} user=$user")
                    block(AuthenticatedRequest(user, request))
                  case None =>
                    logger.error(s"Unauthorized: User not found with id=${s.get}")
                    Future.successful(Results.Unauthorized(errorResponse))
                  }
                case e: JsError =>
                  logger.error(s"Unauthorized: Jwt decode Json error $e")
                  Future.successful(Results.Unauthorized(errorResponse))
              }
            case Failure(e) =>
              logger.error(s"Unauthorized: Jwt decode Json error", e)
              Future.successful(Results.Unauthorized(errorResponse))
          }
        case None =>
          logger.error(s"Unauthorized: Missing token in Authorization header | cookies | session | query string")
          Future.successful(Results.Unauthorized(errorResponse))
      }
    }
  }
} 

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

import com.amazonaws.services.sqs.model.Message
import domain.common.{ MessageToken, ProcessableMessage, ReceivedMessage, UnprocessableMessage }
import play.api.libs.json.{ JsError, JsSuccess, Json, Reads }

object ReceivedMessageConverters {

  def toReceivedMessage[T](message: Message)(implicit reads: Reads[T]): ReceivedMessage[T] = {
    val json = Json.parse(message.getBody)
    val result = Json.fromJson(json)
    val token = MessageToken(message.getReceiptHandle)
    result match {
      case JsSuccess(t, _) => ProcessableMessage(t, token)
      case JsError(e) =>
        val errorMessage = s"messageId: ${ message.getMessageId }, reason: ${ Json.stringify(JsError.toJson(e)) }"
        UnprocessableMessage(new IllegalArgumentException(errorMessage), token)
    }
  }
} 

//设置package包名称以及导入依赖的类
package org.zalando.hutmann.authentication

import play.api.Logger
import play.api.libs.json.{ JsError, JsSuccess, JsValue }

trait OAuth2Response

final case class OAuth2Success[T <: OAuth2User](user: T) extends OAuth2Response
final case class OAuth2Failure[T <: OAuth2Error](failure: T) extends OAuth2Response

object OAuth2Response {
  implicit val userFormat = User.app2AppUserReader
  implicit val errorFormat = AuthError.format

  def fromJson(json: JsValue): OAuth2Response = {
    json.validate[User] match {
      case JsSuccess(user, _) => OAuth2Success(user)
      case JsError(error) =>
        json.validate[AuthError] match {
          case JsSuccess(failure, _) => OAuth2Failure(failure)
          case JsError(fail) =>
            Logger.warn("Failed to parse oauth response from auth server")
            OAuth2Failure(AuthError("Parser failed", "Failed to parse response from OAuth server."))
        }
    }
  }
} 

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

import javax.inject.Inject

import dao.KakeiboJsonDataDao
import models.KakeiboJsonData
import play.api.libs.json.{JsError, Json}
import play.api.mvc.{Action, BodyParsers, Controller}
import play.api.libs.concurrent.Execution.Implicits.defaultContext



class KakeiboApiController @Inject() (kakeiboJsonDataDao: KakeiboJsonDataDao) extends Controller{

  import models.KakeiboJsonConvertImplicits._;

  def saveItems = Action(BodyParsers.parse.json) { request =>
    val result = request.body.validate[KakeiboJsonData]

    result.fold(
      errors => {
        BadRequest(Json.obj("status" ->"KO", "message" -> JsError.toJson(errors)))
      },
      data => {
        kakeiboJsonDataDao.insert(data)
        Ok(Json.obj("status" ->"OK", "message" -> (" kakeibo json data is saved.") ))
      }
    )
  }

  def items = Action.async { request =>
    kakeiboJsonDataDao.all.map(items => {
      val json = Json.toJson(items)
      Ok(json)
    })
  }

} 

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

import java.nio.file.{Files, Paths}

import codacy.dockerApi.api.CodacyConfiguration
import play.api.data.validation.ValidationError
import play.api.libs.json.{JsError, JsPath, Json}

import scala.util.{Failure, Success, Try}

object DockerEnvironment {

  def config: Try[CodacyConfiguration] = Try(Files.readAllBytes(configFilePath)).transform(
    raw => Try(Json.parse(raw)).flatMap(
      _.validate[CodacyConfiguration].fold(
        asFailure,
        conf => Success(conf)
      )),
    error => Failure(error)
  )

  private[this] def asFailure(error: Seq[(JsPath, Seq[ValidationError])]) =
    Failure(new Throwable(Json.stringify(JsError.toFlatJson(error.toList))))

  private[this] lazy val configFilePath = sourcePath.resolve(".codacyrc")

  lazy val sourcePath = Paths.get("/src")
} 

//设置package包名称以及导入依赖的类
package mesosphere.marathon.integration.setup

import play.api.libs.json.{ JsError, JsSuccess, Json, Reads }
import spray.http.HttpResponse

import scala.reflect.ClassTag

object SprayHttpResponse {
  def read[T](implicit reads: Reads[T], classTag: ClassTag[T]): HttpResponse => RestResult[T] = responseResult.andThen { result =>
    result.map(_ => Json.fromJson(result.entityJson)).map {
      case JsSuccess(value, _) => value
      case JsError(errors) =>
        throw new IllegalArgumentException(
          s"could not parse as $classTag:\n${Json.prettyPrint(result.entityJson)}\nErrors:\n${errors.mkString("\n")}")
    }
  }
  def responseResult: HttpResponse => RestResult[HttpResponse] = response => RestResult(response)
} 

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

import javax.inject._

import dao.UserDAO
import models.{Bad, User}
import play.api.mvc._
import play.api.libs.json.{JsError, JsSuccess, Json, _}
import play.api.Mode
import system.MyExecutionContext

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration
import scala.concurrent.Future



  def index = Action {
    Ok(views.html.index("Your new application is ready."))
  }
implicit val userformat = Json.format[User]


  def create = Action.async(parse.json) { implicit request =>
    val validationResult: JsResult[User] = request.body.validate[User]
      validationResult match {
        case r: JsSuccess[User] =>
          val user:User=r.get
         val futureLong : Future[Long] =  userDAO.insert(user)
          futureLong.map{
            result => Ok("success")
          }
        case r: JsError =>
          scala.concurrent.Future {
            val errors = JsError.toJson(r)
            Ok(Json.toJson(Bad(Some(430), "bad.request", data = errors)))
          }
      }
  }


  def getAll = Action.async { implicit rs =>
    val users : Future[Seq[User]] =  userDAO.all()
    users.map(u => Ok(Json.toJson(u)))
  }



  def deleteUser(id:Long) = Action.async {  implicit request =>
      userDAO.delete(id).map(num => Ok(Json.toJson(num)))
  }


  def getById(id:Long) =Action.async{  implicit request =>
    userDAO.findById(id).map(num => Ok(Json.toJson(num)))
  }

} 

//设置package包名称以及导入依赖的类
package org.birdfeed.chirp.errors

import play.api.data.validation.ValidationError
import play.api.libs.json.{JsError, JsPath, JsValue, Json}

trait JsonError {
  def jsonException(message: String, exception: Exception = new Exception): JsValue = {
    Json.obj(
      "error" -> message,
      "details" -> Json.obj(
        "exception_class" -> exception.getClass.toString,
        "message" -> exception.toString
      )
    )
  }

  def jsonError(message: String): JsValue = Json.obj(
    "error" -> message
  )

  def jsonValidationError(message: String, errors: Seq[(JsPath, Seq[ValidationError])]): JsValue = {
    Json.obj("error" -> message, "details" -> JsError.toJson(errors))
  }
} 

//设置package包名称以及导入依赖的类
package se.andrisak.backprop.rest

import javax.inject.Inject

import play.api.libs.json.{JsError, Json}
import play.api.mvc._
import se.andrisak.backprop.algo.BackPropagationAlgo
import se.andrisak.backprop.rest.model.ClassificationRequest.ClassificationInput
import se.andrisak.backprop.rest.model.ClassificationResponse.Classification

import scala.util.Random


class BackPropagationService @Inject()(random: Random) extends Controller {
  def classify = Action(BodyParsers.parse.json) { request =>
    val r = request.body.validate[ClassificationInput]

    r.fold(
      errors => {
        BadRequest(Json.obj("message" -> JsError.toJson(errors)))
      },
      classification => {
        val iterations = classification.valuesToClassify.iterations
        val trainingData = classification.trainingData
        val bp = new BackPropagationAlgo(random)
        val firstInput = classification.valuesToClassify.firstInput
        val secondInput = classification.valuesToClassify.secondInput
        val output = bp.classify(iterations, trainingData, List(firstInput, secondInput))

        Ok(Json.toJson(Classification(firstInput, secondInput, output)))
      })
  }
} 

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

import com.google.inject.{ImplementedBy, Inject, Singleton}
import org.apache.http.HttpStatus
import play.api.Logger
import play.api.libs.json.{JsError, JsSuccess, Json}
import play.api.libs.ws.WSClient
import services.endpoints.GOAuthEndpoints
import services.exceptions.ParseException
import services.models.UserInfo
import services.status.{AuthFailure, LoginStatus, LoginSuccess}

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

@ImplementedBy(classOf[GOAuthServicesImpl])
trait OAuthServices {
  def getUserInfo(accessToken: String): Future[LoginStatus[UserInfo]]
}

@Singleton
class GOAuthServicesImpl @Inject()(gOAuthEndpoints: GOAuthEndpoints, wsClient: WSClient) extends OAuthServices {
  override def getUserInfo(accessToken: String): Future[LoginStatus[UserInfo]] = {
    wsClient.url(gOAuthEndpoints.userInfoURL(accessToken)).get().flatMap { wsResponse =>
      val status = wsResponse.status
      if (status == HttpStatus.SC_OK) {
        Logger.info(s"""response body as string: ${wsResponse.body}""")
        val payload = Json.parse(wsResponse.body)
        payload.validate[UserInfo] match {
          case JsSuccess(userInfo, _) => Future.successful(LoginSuccess(userInfo))
          case [email protected](errors) => Future.failed(ParseException(s"Errors while parsing the json payload into user info object: ${errors.mkString(" ")}"))
        }
      } else if (status == HttpStatus.SC_UNAUTHORIZED) {
        Future.successful(AuthFailure)
      } else {
        Future.failed(new Exception("Unknown http status: " + status))
      }
    }
  }
} 

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

import play.api.http.{Writeable, ContentTypes, ContentTypeOf}
import play.api.libs.json.JsError
import play.api.mvc.{Request, Codec}
import scala.concurrent.ExecutionContext.Implicits.global

object `package` {

  def isAjax[A](implicit request : Request[A]) = request.headers.get("X-Requested-With").contains("XMLHttpRequest")

  implicit def contentTypeOf_Throwable(implicit codec: Codec): ContentTypeOf[Throwable] =
    ContentTypeOf[Throwable](Some(ContentTypes.TEXT))

  implicit def writeableOf_Throwable(implicit codec: Codec): Writeable[Throwable] = {
    Writeable(e => e.getMessage.getBytes("utf-8"))
  }

  implicit def contentTypeOf_JsError(implicit codec: Codec): ContentTypeOf[JsError] =
    ContentTypeOf[JsError](Some(ContentTypes.JSON))

  implicit def writeableOf_JsError(implicit codec: Codec): Writeable[JsError] = {
    Writeable(e => JsError.toJson(e).toString.getBytes("utf-8"))
  }
} 

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

import dao.TagDao
import models.Tag
import play.api.libs.json.{Json, JsError}
import play.api.mvc.{Action, Controller}

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

class TagController(tagDao: TagDao, auth: SecuredAuthenticator) extends Controller {

  def index = Action.async { request =>
    tagDao.findAll().map { tags =>
      Ok(Json.toJson(tags))
    }
  }

  def create = auth.JWTAuthentication.async(parse.json) { request =>
    val tagResult = request.body.validate[Tag]
    tagResult.fold(
      valid = { t =>
        val tag = tagDao.add(t)
        tag.map(t => Created(Json.toJson(t))).recoverWith {
          case _ => Future { InternalServerError}
        }
      },
      invalid = { errors =>
        Future.successful(
          BadRequest(JsError.toJson(errors))
        )
      }
    )
  }

  def destroy(id: Long) = auth.JWTAuthentication.async { request =>
    tagDao.remove(id).map(tag => Ok(s"Tag with id: ${id} removed")).recoverWith {
      case _ => Future { NotFound }
    }
  }
} 

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

import com.google.inject.Inject
import model.dto.RawWordRestIn
import play.api.Logger
import play.api.libs.json.JsError
import play.api.mvc._
import service.{RawWordRequestService, WordService}


class WordController @Inject()(requestService: RawWordRequestService, wordService: WordService) extends Controller {

  def add = Action(BodyParsers.parse.json) { implicit request =>
    Logger.debug("{ADD} save request")
    requestService.save(request.body)

    Logger.debug("{ADD} validate and parse body from request")
    request.body.validate[RawWordRestIn].fold(
      errors =>
        BadRequest(JsError.toJson(errors)),
      word => {
        wordService.add(word.word)
        Created
      }
    )
  }
} 

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

import javax.inject.Inject

import model.RawWord
import model.ywordmodel.YTranslateWord
import play.api.libs.json.{JsError, Json}
import play.api.mvc._
import services.TranslateService

import scala.concurrent.Future

class RawWordController @Inject()(translateService: TranslateService) extends Controller {

  def add = Action.async(BodyParsers.parse.json) { implicit request =>
    request.body.validate[RawWord].fold(
      errors =>
        Future.successful(BadRequest(JsError.toJson(errors))),
      word =>
        Future.successful(Ok(Json.toJson(translateService.translate(word))))
    )
  }

  def addTranslate() = Action.async(BodyParsers.parse.json) { implicit request =>
    request.body.validate[YTranslateWord].fold(
      errors =>
        Future.successful(BadRequest(JsError.toJson(errors))),
      word =>
        Future.successful(Ok(Json.toJson(word)))
    )
  }

} 

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

import akka.actor.Status.Success
import models.{Tasks, Task}
import play.api.Play
import play.api.libs.json.{JsPath, Reads, JsError}
import play.api.libs.functional.syntax._
import play.api.mvc._

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future


class TaskController extends Controller {

  implicit val locationReads: Reads[Task] = (
    (JsPath \ "id").read[Long] and
      (JsPath \ "title").read[String]
    )(Task.apply _)

  def index = Action.async { implicit request =>
    Tasks.all.map { users =>
      Ok(views.html.tasks(users))
    }
  }

  def create = Action(parse.json) { implicit request =>
    request.body.validate[Task].map {
      case Task(i, t) => {
        Tasks.add(new Task(i, t))
        Redirect(routes.TaskController.index)
      }
    }.recoverTotal {
      e => BadRequest("Detected error:"+ JsError.toFlatJson(e))
    }
  }

  def read = TODO

  def update = TODO

  def delete = TODO

} 

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

import com.google.inject.Inject
import dao._
import models.{Cat, Dog}
import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.json.{JsError, JsSuccess, Json}
import play.api.mvc._

import scala.concurrent.Future

class Application @Inject() (catDao: CatDAO, dogDao: DogDAO) extends Controller {

  def info = Action { implicit request =>
    ???
  }

  def findAllAnimals = Action.async { implicit request =>
    catDao.all().zip(dogDao.all()).map {
      case (cats, dogs) =>
        val catsJson = Json.toJson(cats)
        val dogsJson = Json.toJson(dogs)
        Ok(Json.obj(
          "cats" -> catsJson,
          "dogs" -> dogsJson
        ))
    }
  }

  def insertCat = Action.async(parse.json) { implicit request =>
    request.body.validate[Cat] match {
      case JsSuccess(cat, path) =>
        catDao.insert(cat).map(_ => Ok(Json.obj("msg" -> "Cat was inserted")))

      case JsError(err) =>
        Future.successful(BadRequest(Json.obj("msg" -> err.mkString("\n"))))
    }
  }

  def insertDog = Action.async(parse.json) { implicit request =>
    request.body.validate[Dog] match {
      case JsSuccess(dog, path) =>
        dogDao.insert(dog).map(_ => Ok(Json.obj("msg" -> "Dog was inserted")))

      case JsError(err) =>
        Future.successful(BadRequest(Json.obj("msg" -> err.mkString("\n"))))
    }
  }

} 

//设置package包名称以及导入依赖的类
package com.waltsu.wdht

import java.util.concurrent.Executors

import colossus._
import core._
import service._
import protocols.http._
import UrlParsing._
import HttpMethod._
import com.typesafe.config.ConfigFactory
import com.waltsu.wdht.storage.models.StoredObject
import play.api.libs.json.{JsError, JsSuccess, JsValue, Json}

import scala.concurrent.{Await, ExecutionContext, Future}
import scala.concurrent.duration._
import scala.language.postfixOps
import scala.concurrent.{ExecutionContext, Future}

object WDHTServer {
  private implicit val executionContext = ExecutionContext.fromExecutor(Executors.newFixedThreadPool(10))
}
class WDHTServer(context: ServerContext) extends HttpService(context) {
  import WDHTServer._

  private val RequestTimeout = ConfigFactory.load().getInt("wdht.requestTimeout") seconds

  def handle = {
    case request @ Get on Root / key => Callback.fromFuture(getObject(request, key))
    case request @ Put on Root / key => Callback.fromFuture(putObject(request, key))
    case request => Callback.successful(request.notFound("not found"))
  }

  private def getObject(request: HttpRequest, key: String): Future[HttpResponse] = {
    DistributedHashTable.get(key).map {
      case Some(storedObject) =>
        request.ok(Json.toJson(storedObject).toString)
      case None => request.notFound("")
    }
  }

  private def putObject(request: HttpRequest, key: String): Future[HttpResponse] = {
    (Json.parse(request.body.toString) \ "value").validate[String] match {
      case value: JsSuccess[String] =>
        DistributedHashTable.put(key, value.value).map((storedObject) => {
          request.ok(Json.toJson(storedObject).toString())
        })
      case error: JsError =>
        Future { request.badRequest("Errors: " + JsError.toJson(error).toString()) }
    }
  }
}

class WDHTInitializer(worker: WorkerRef) extends Initializer(worker) {
  def onConnect = context => new WDHTServer(context)
}