scala – 如何集成Play(Web框架),Deadbolt(授权)和Slick(数据库

这是DeadboltHandler的通用实现;你应该能够将它放入你的代码并按原样使用它,因为稍后将处理持久性细节.

import javax.inject.{Inject,Singleton}

import be.objectify.deadbolt.scala.models.Subject
import be.objectify.deadbolt.scala.{AuthenticatedRequest,DeadboltHandler,DynamicResourceHandler}
import models.{LogInForm,User}
import play.api.mvc.{Request,Result,Results}
import play.twirl.api.HtmlFormat
import views.html.security.denied

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

@Singleton
class MyDeadboltHandler @Inject() (authSupport: AuthSupport) extends DeadboltHandler {

  override def beforeAuthCheck[A](request: Request[A]): Future[Option[Result]] = Future {None}

  override def getDynamicResourceHandler[A](request: Request[A]): Future[Option[DynamicResourceHandler]] = Future {None}

  /**
    * Get the current user.
    *
    * @param request the HTTP request
    * @return a future for an option maybe containing the subject
    */
  override def getSubject[A](request: AuthenticatedRequest[A]): Future[Option[Subject]] = 
    Future {
      request.subject.orElse {
        // replace request.session.get("userId") with how you identify the user
        request.session.get("userId") match {
          case Some(userId) => authSupport.getUser(userId)
          case _ => None
        }
      }}

  /**
    * Handle instances of authorization failure.
    *
    * @param request the HTTP request
    * @return either a 401 or 403 response,depending on the situation
    */
  override def onAuthFailure[A](request: AuthenticatedRequest[A]): Future[Result] = {
    def toContent(maybeSubject: Option[Subject]): (Boolean,HtmlFormat.Appendable) =
      maybeSubject.map(subject => subject.asInstanceOf[User])
      .map(user => (true,denied(Some(user))))
      .getOrElse {(false,views.html.security.logIn(LogInForm.logInForm))}

    getSubject(request).map(maybeSubject => toContent(maybeSubject))
    .map(subjectPresentAndContent =>
      if (subjectPresentAndContent._1) Results.Forbidden(subjectPresentAndContent._2)
      else Results.Unauthorized(subjectPresentAndContent._2))
  }
}

现在,转到数据库的需要减少到尚未将主题放入请求的情况.请注意有关替换request.session.get(“userId”)的注释,但要标识用户.

然后,AuthSupport类提供对主题持久性的访问.这将DB访问与DeadboltHandler隔离开来.它非常简单,主要是因为您将使用Slick查询填充此内容.

@Singleton
class AuthSupport @Inject()(dbConfigProvider: DatabaseConfigProvider) {
    // set up your usual Slick support

    // use Slick to get the subject from the database
    def getUser(userId: String): Option[User] = ???
}

要公开它,您需要创建一个模块并在application.conf中注册它.

import be.objectify.deadbolt.scala.DeadboltHandler
import be.objectify.deadbolt.scala.cache.HandlerCache
import security.{AuthSupport,MyDeadboltHandler,MyHandlerCache}
import play.api.inject.{Binding,Module}
import play.api.{Configuration,Environment}

class CustomBindings extends Module  {
  override def bindings(environment: Environment,configuration: Configuration): Seq[Binding[_]] =
    Seq(
         bind[DeadboltHandler].to[MyDeadboltHandler],bind[AuthSupport].toSelf,// other bindings,such as HandlerCache
       )
}

在application.conf中声明它是使用play.modules.enabled的常见问题：

play {
  modules {
    enabled += be.objectify.deadbolt.scala.DeadboltModule
    enabled += modules.CustomBindings
  }
}