Scala ControllerComponents类代码示例

//设置package包名称以及导入依赖的类
package org.splink.pagelets

import play.api.mvc.{ControllerComponents, InjectedController}

class InjectedPageletsAssembly extends InjectedController with PageletsAssembly

trait PageletsAssembly extends Pagelets
  with PageletActionsImpl
  with PageBuilderImpl
  with LeafBuilderImpl
  with ActionBuilderImpl
  with TreeToolsImpl
  with ResourceActionsImpl
  with ResourcesImpl
  with VisualizerImpl {
  protected def controllerComponents: ControllerComponents
} 

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

import javax.inject.{Inject, Singleton}

import database.UsersCollection
import models.User
import play.api.libs.json.JsValue
import play.api.mvc.{Action, BaseController, ControllerComponents}

import scala.concurrent.{ExecutionContext, Future}



@Singleton
class UsersController @Inject()(
  val controllerComponents: ControllerComponents,
  users: UsersCollection
)(implicit ec: ExecutionContext) extends BaseController {

  def create: Action[JsValue] = Action.async(parse.json) { request =>
    request.body.asOpt[User] match {
      case Some(user) => users.insert(user).map(if(_) Created else InternalServerError)
      case None => Future.successful(BadRequest)
    }
  }

  def read(id: String) = Action {
    users.find(id)
    Ok
  }

} 

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

import javax.inject.Inject

import org.scalatest._
import org.scalatest.Matchers._
import play.api.inject.guice.GuiceApplicationBuilder
import play.api.mvc.{ AbstractController, ControllerComponents }
import play.api.test.Helpers._
import play.api.test.FakeRequest

class OAuth2ProviderActionBuildersSpec extends FlatSpec {

  class MyController @Inject() (components: ControllerComponents)
      extends AbstractController(components) with OAuth2ProviderActionBuilders {

    val action = AuthorizedAction(new MockDataHandler) { request =>
      Ok(request.authInfo.user.name)
    }

  }

  val injector = new GuiceApplicationBuilder().injector()
  val controllerComponents = injector.instanceOf[ControllerComponents]

  it should "return BadRequest" in {
    val controller = new MyController(controllerComponents)
    val result = controller.action(FakeRequest())
    status(result) should be(400)
    contentAsString(result) should be("")
  }

} 

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

import javax.inject.{Inject, Singleton}

import dao.{DatabrickAuditLogDAO, UserDAO}
import play.api.db.slick.{DatabaseConfigProvider, HasDatabaseConfigProvider}
import play.api.mvc.{AbstractController, ControllerComponents}
import slick.jdbc.JdbcProfile

import scala.concurrent.ExecutionContext


@Singleton
class DBController @Inject()(
                            userDao:UserDAO,
                            databrickAuditLogDao: DatabrickAuditLogDAO,
                              protected val dbConfigProvider: DatabaseConfigProvider,
                              cc: ControllerComponents
                            )
                            (implicit ec: ExecutionContext)
  extends AbstractController(cc) with HasDatabaseConfigProvider[JdbcProfile] {
  def init = Action { implicit request =>
    Ok("success")
  }

} 

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

import com.google.inject.Inject
import helpers.Auth0Config
import models.Auth0Model
import play.api.cache.SyncCacheApi
import play.api.libs.json.JsValue
import play.api.mvc.{AbstractController, ControllerComponents}

import scala.concurrent.ExecutionContext

class UserController @Inject()(val components: ControllerComponents, cache: SyncCacheApi, val Auth0Config: Auth0Config,
                               auth0Controller: Auth0Controller)(implicit exec: ExecutionContext)
extends AbstractController(components) {

  def getUser = auth0Controller.AuthenticatedAction { request =>
    val idToken = request.session.get("idToken").get
    val profile = cache.get[JsValue](idToken + "profile").get
    val profileModel = profile.as[Auth0Model]
      Ok(views.html.user(profileModel))
  }

} 

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

import com.google.inject.Inject
import com.mohiva.play.silhouette.api.{LogoutEvent, Silhouette}
import play.api.mvc.{AbstractController, ControllerComponents}
import utils.JsonResults
import utils.auth.DefaultEnv

class SignOutController @Inject() (
                                    components: ControllerComponents,
                                    silhouette: Silhouette[DefaultEnv]
                                  ) extends AbstractController(components) {

  def submit = silhouette.SecuredAction.async { implicit request =>
    silhouette.env.eventBus.publish(
      LogoutEvent(request.identity, request)
    )
    silhouette.env.authenticatorService.discard(
      request.authenticator,
      Ok(JsonResults.success("User signed out"))
    )
  }
} 

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

import java.util.Locale
import javax.inject.{Inject, Singleton}
import play.api.mvc.{AbstractController, AnyContent, ControllerComponents}

@Singleton
class UserController @Inject() (cc: ControllerComponents) extends AbstractController(cc) {
  def create = Action { request =>
    val body: AnyContent = request.body

    val contentType: Option[String] = request.contentType.map(_.toLowerCase(Locale.ENGLISH))
    println(contentType)

    val name = body.asText
    println(name)
    Ok("not implemented")
  }

  def get(id: Int) = Action {
    println(id)
    Ok("not implemented")
  }

  def delete(id: Int) = Action {
    println(id)
    Ok("not implemented")
  }
} 

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

import javax.inject.Inject

import play.api.Logger
import play.api.data.Form
import play.api.data.Forms._
import play.api.i18n.I18nSupport
import play.api.libs.json.Json
import play.api.mvc.{AbstractController, ControllerComponents}
import v1.food.FoodResourceHandler
import views.html.defaultpages.notFound

import scala.concurrent.{ExecutionContext, Future}

case class FoodFormData(name: String)

class FoodController @Inject()(handler: FoodResourceHandler, cc: ControllerComponents)(implicit ec: ExecutionContext)
  extends AbstractController(cc) with I18nSupport {

  private val log = Logger(classOf[FoodController])
  val foodForm = Form(
    mapping(
      "name" -> text
    )(FoodFormData.apply)(FoodFormData.unapply)
  )

  def index(filters: String) = Action.async {
    log.info(s"filters=$filters")
    if (log.isInfoEnabled) println("Info is enabled")
    handler.list.map { foodResources =>
      Ok(Json.toJson(foodResources))
    }
  }

  def show(id: String) = Action.async { implicit request =>
    handler.get(id).map {
      case Some(foodResource) => Ok(Json.toJson(foodResource))
      case None => NotFound(notFound(request.method, request.uri))
    }
  }

  def create = Action.async { implicit request =>
    def failure(badForm: Form[FoodFormData]) = {
      Future.successful(BadRequest(badForm.errorsAsJson))
    }

    def success(input: FoodFormData) = {
      handler.create(input).map { food =>
        Created(Json.toJson(food)).withHeaders(LOCATION -> food.link)
      }
    }

    foodForm.bindFromRequest().fold(failure, success)
  }
} 

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

import javax.inject.Inject

import model.CommonProps
import play.api.libs.json.Json
import play.api.mvc.{AbstractController, ControllerComponents}
import repo.SubscriptionRepo
import model.b2c.Error

class SubscriptionController @Inject()(cc:ControllerComponents,subscriptionRepo: SubscriptionRepo)
  extends AbstractController(cc) {

  def getSubscriptionById(id: String) = Action {
    if (id.size == 24 && id.matches(CommonProps.HexadecimalRegexp)) {
      val subscription = subscriptionRepo.getSubscriptionById(id)
      if (subscription == None) {
        NotFound(CommonProps.EmptyResponse)
      } else {
        Ok(Json.toJson(subscriptionRepo.getSubscriptionById(id)))
      }
    }
    else BadRequest(Json.toJson(Error.mustBeHexadecimal("SubscriptionId")))
  }

  def deleteSubscriptionById(id: String) = Action {
    if (id.size == 24 && id.matches(CommonProps.HexadecimalRegexp)) {
      if (subscriptionRepo.deleteSubscriptionById(id) > 0) {
        Ok(CommonProps.EmptyResponse)
      }
      else NotFound(CommonProps.EmptyResponse)
    }
    else BadRequest(Json.toJson(Error.mustBeHexadecimal("SubscriptionId")))
  }

  def getAllSubscriptionsForEmail(email: String) = Action {
    if (email.matches(CommonProps.EmailRegexp)){
      Ok(Json.toJson(subscriptionRepo.findAllSubscriptionsForEmail(email)))
    } else {
      BadRequest(Json.toJson(new Error("Invalid email","Invalid email format")))
    }
  }

}