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

import actors.ChadashSystem
import com.google.inject.{Guice, Module}
import play.api.mvc.{EssentialAction, Filters}
import play.api.{Application, GlobalSettings, Logger, Mode}
import play.filters.gzip.GzipFilter
import play.filters.headers.SecurityHeadersFilter

trait AppGlobalSettings extends GlobalSettings {

  private var INJECTOR: Option[com.google.inject.Injector] = None

  def injectorModules(): Seq[Module]

  override def onStart(app: Application) {
    INJECTOR = Some(Guice.createInjector(injectorModules(): _*))
  }

  override def onStop(app: Application) {
    Logger.info("Application shutdown...")
    if(app.mode != Mode.Test)
      ChadashSystem.system.shutdown()
  }

  override def doFilter(next: EssentialAction): EssentialAction = {
    Filters(super.doFilter(next), new GzipFilter(), SecurityHeadersFilter())
  }

  override def getControllerInstance[A](controllerClass: Class[A]): A = {
    INJECTOR match {
      case Some(x) => x.getInstance(controllerClass)
      case None => throw new UnsupportedOperationException("The DI framework has not been setup yet!")
    }
  }
} 

//设置package包名称以及导入依赖的类
package ejisan.play.i18n

import play.api.mvc.Controller
import play.api.i18n.{ I18nSupport, MessagesApi, Lang }

import scala.concurrent.duration.Duration
import play.api.mvc.{ Action, EssentialAction }
import play.api.i18n.{ MessagesApi, Lang }
import play.api.libs.json.{ Json, JsValue }
import play.api.cache.CacheApi
import play.twirl.api.JavaScript

trait JsI18nSupport { self: Controller with I18nSupport =>
  object JsI18nAction {
    val script: EssentialAction = Action { self.Ok(JsI18nHelper.script) }

    def messages(prefix: String, variable: String): EssentialAction = Action {
      implicit request =>
      self.Ok(JsI18nHelper.messagesWithScriptJs(translateMessages(messagesApi, prefix), variable))
    }

    def additionalMessages(prefix: String, variable: String): EssentialAction = Action {
      implicit request =>
      self.Ok(JsI18nHelper.messagesAdditionJs(translateMessages(messagesApi, prefix), variable))
    }

    def messagesJson(prefix: String): EssentialAction = Action { implicit request =>
      self.Ok(Json.toJson(translateMessages(messagesApi, prefix)))
    }
  }

  def translateMessages(messagesApi: MessagesApi)
    (implicit lang: Lang): Map[String, String] =
    translateMessages(messagesApi, None)

  def translateMessages(messagesApi: MessagesApi, prefix: String)
    (implicit lang: Lang): Map[String, String] =
    translateMessages(messagesApi, Option(prefix).filter(!_.isEmpty))

  def translateMessages(messagesApi: MessagesApi, prefix: Option[String])
    (implicit lang: Lang): Map[String, String] = {
      val px = prefix.map(p => if (p.endsWith(".")) p else p + ".")
      val keys = messagesApi.messages
        .map({case (_, value)=>value.keySet})
        .flatten.toSet
      keys
        .map(key => (key -> messagesApi.translate(key, Nil)(lang)))
        .collect({ case (key, Some(value)) if px.map(key.startsWith(_)).getOrElse(true) =>
            px.map(key.stripPrefix(_)).getOrElse(key) -> value
        }).toMap
    }
} 

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

import akka.util.ByteString
import kamon.trace.Tracer
import kamon.util.SameThreadExecutionContext
import play.api.libs.streams.Accumulator
import play.api.mvc.{ EssentialAction, EssentialFilter, RequestHeader, Result }

class KamonFilter extends EssentialFilter {

  override def apply(next: EssentialAction): EssentialAction = new EssentialAction {
    override def apply(requestHeader: RequestHeader): Accumulator[ByteString, Result] = {

      def onResult(result: Result): Result = {
        Tracer.currentContext.collect { ctx ?
          ctx.finish()
          PlayExtension.httpServerMetrics.recordResponse(ctx.name, result.header.status.toString)
          if (PlayExtension.includeTraceToken) result.withHeaders(PlayExtension.traceTokenHeaderName -> ctx.token)
          else result

        } getOrElse result
      }

      //override the current trace name
      Tracer.currentContext.rename(PlayExtension.generateTraceName(requestHeader))
      val nextAccumulator = next.apply(requestHeader)
      nextAccumulator.map(onResult)(SameThreadExecutionContext)
    }
  }

} 

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

import play.core.server.{ AkkaHttpServer, ServerConfig }
import play.api.mvc.EssentialAction
import play.api.routing.sird._
import play.api.routing.Router


object TestSocketIOServer {

  def start(testApplication: TestSocketIOApplication, config: ServerConfig = ServerConfig()): AkkaHttpServer = {
    AkkaHttpServer.fromApplication(
      testApplication.createApplication { (assets, controller, executionContext) =>
        def extAssets: String => EssentialAction = assets.at("src/test/javascript", _)
        implicit val ec = executionContext
        Router.from {
          case GET(p"/socket.io/") ? q"transport=$transport"  => controller.endpoint(transport)
          case POST(p"/socket.io/") ? q"transport=$transport" => controller.endpoint(transport)
          case GET(p"$path*") => EssentialAction { rh =>
            (if (path.endsWith("/")) {
              extAssets(path + "index.html")
            } else {
              extAssets(path)
            }).apply(rh).map(_.withHeaders("Cache-Control" -> "no-cache"))
          }
        }
      }, config
    )
  }

  def main(testApplication: TestSocketIOApplication) = {
    val server = start(testApplication)
    println("Press enter to terminate application.")
    System.in.read()
    server.stop()
  }
} 

//设置package包名称以及导入依赖的类
import javax.inject._

import akka.stream.Materializer
import filters.GoogleFilter
import play.api.http.HttpFilters
import play.api.mvc.EssentialAction
import play.filters.gzip.GzipFilter

@Singleton
class Filters @Inject() (googleFilter: GoogleFilter, implicit val mat: Materializer) extends HttpFilters {
  val next: EssentialAction = null
  val ret = googleFilter(next)

  override val filters =
    Seq(
      new GzipFilter(shouldGzip = (request, response) => {
          val contentType = response.body.contentType.getOrElse("").toLowerCase
          contentType.contains("text") || contentType.contains("json") || contentType.contains("javascript")
        }
      ),
      googleFilter
    )

}