使用剪影 4.0 播放 2.5 - 凭据提供程序 [英] Play 2.5 with Silhouette 4.0 - Credential Provider

问题描述

我正在尝试使用Silhouette 4.0为用户/密码身份验证编写带有Play 2.5的示例应用程序.

I am trying to write a sample app with Play 2.5 using Silhouette 4.0 for user/password authentication.

源代码位于:https://github.com/pariksheet/dribble

我被困在环境对象中设置 requestProvider

I am stuck at setting requestProvider in Environment object

Environment[JWTEnv](
  identityService,
  authenticatorService,
  Seq(),
  eventBus
)

由于我无法找出解决方案，所以我在所有控制器类中注入了 Credential Provider.

As I am not able to figure out the solution, I am injecting Credential Provider in my all controller classes.

    class MyController @Inject() (val messagesApi: MessagesApi,val silhouette: Silhouette[JWTEnv],
  authInfoRepository: AuthInfoRepository,
  credentialsProvider: CredentialsProvider)
    extends Controller {
          def authenticate = Action.async(BodyParsers.parse.json) { implicit request =>
        credentialsProvider.authenticate(Credentials(data.email, data.password)).flatMap { loginInfo => ..}    
         //   silhouette.env.requestProviders.foreach { x => println("====" + x.id) }  --- I am hoping to get credential provider from silhouette object

        ...
        ...
        }
    }

我的 Module.scala 如下 -

My Module.scala as below -

package module

import com.google.inject.AbstractModule
import com.google.inject.Provides
import com.mohiva.play.silhouette.api.Env
import com.mohiva.play.silhouette.api.Environment
import com.mohiva.play.silhouette.api.EventBus
import com.mohiva.play.silhouette.api.Silhouette
import com.mohiva.play.silhouette.api.SilhouetteProvider
import com.mohiva.play.silhouette.api.crypto.Base64AuthenticatorEncoder
import com.mohiva.play.silhouette.api.repositories.AuthInfoRepository
import com.mohiva.play.silhouette.api.services.AuthenticatorService
import com.mohiva.play.silhouette.api.services.AvatarService
import com.mohiva.play.silhouette.api.services.IdentityService
import com.mohiva.play.silhouette.api.util.CacheLayer
import com.mohiva.play.silhouette.api.util.Clock
import com.mohiva.play.silhouette.api.util.FingerprintGenerator
import com.mohiva.play.silhouette.api.util.HTTPLayer
import com.mohiva.play.silhouette.api.util.IDGenerator
import com.mohiva.play.silhouette.api.util.PasswordHasher
import com.mohiva.play.silhouette.api.util.PasswordHasherRegistry
import com.mohiva.play.silhouette.api.util.PasswordInfo
import com.mohiva.play.silhouette.api.util.PlayHTTPLayer
import com.mohiva.play.silhouette.impl.authenticators.JWTAuthenticator
import com.mohiva.play.silhouette.impl.authenticators.JWTAuthenticatorService
import com.mohiva.play.silhouette.impl.authenticators.JWTAuthenticatorSettings
import com.mohiva.play.silhouette.impl.providers.CredentialsProvider
import com.mohiva.play.silhouette.impl.services.GravatarService
import com.mohiva.play.silhouette.impl.util.DefaultFingerprintGenerator
import com.mohiva.play.silhouette.impl.util.PlayCacheLayer
import com.mohiva.play.silhouette.impl.util.SecureRandomIDGenerator
import com.mohiva.play.silhouette.password.BCryptPasswordHasher
import com.mohiva.play.silhouette.persistence.daos.DelegableAuthInfoDAO
import com.mohiva.play.silhouette.persistence.repositories.DelegableAuthInfoRepository

import daos.MongoUserDao
import daos.MongoUserTokenDao
import daos.PasswordInfoDao
import daos.UserDao
import daos.UserTokenDao
import models.User
import net.codingwell.scalaguice.ScalaModule
import play.api.Configuration
import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.ws.WSClient
import services.UserService

trait JWTEnv extends Env {
  type I = User
  type A = JWTAuthenticator
}

class Module extends AbstractModule with ScalaModule {

  def configure() {
    bind[IdentityService[User]].to[UserService]
    bind[UserDao].to[MongoUserDao]
    bind[UserTokenDao].to[MongoUserTokenDao]
    bind[DelegableAuthInfoDAO[PasswordInfo]].to[PasswordInfoDao]
    bind[IDGenerator].toInstance(new SecureRandomIDGenerator())
    bind[PasswordHasher].toInstance(new BCryptPasswordHasher)
    bind[FingerprintGenerator].toInstance(new DefaultFingerprintGenerator(false))
    bind[EventBus].toInstance(EventBus())
    bind[Clock].toInstance(Clock())
    bind[CacheLayer].to[PlayCacheLayer]
    bind[Silhouette[JWTEnv]].to[SilhouetteProvider[JWTEnv]]
  }

  @Provides
  def provideHTTPLayer(client: WSClient): HTTPLayer = new PlayHTTPLayer(client)

  @Provides
  def provideEnvironment(
    identityService: IdentityService[User],
    authenticatorService: AuthenticatorService[JWTAuthenticator],
    eventBus: EventBus): Environment[JWTEnv] = {

    Environment[JWTEnv](
      identityService,
      authenticatorService,
      Seq(),
      eventBus
    )
  }

  @Provides
  def provideAuthenticatorService(
    fingerprintGenerator: FingerprintGenerator,
    idGenerator: IDGenerator,
    configuration: Configuration,
    clock: Clock): AuthenticatorService[JWTAuthenticator] = {
    val settings = JWTAuthenticatorSettings(
      sharedSecret = configuration.getString("application.secret").getOrElse("PARI"))


    new JWTAuthenticatorService(
      settings = settings,
      repository = None,
      authenticatorEncoder = new Base64AuthenticatorEncoder,
      idGenerator = idGenerator,
      clock = Clock())
  }

  @Provides
  def provideAuthInfoRepository(
    passwordInfoDAO: DelegableAuthInfoDAO[PasswordInfo]): AuthInfoRepository = {

    new DelegableAuthInfoRepository(passwordInfoDAO)
  }

  @Provides
  def providePasswordHasherRegistry(passwordHasher: PasswordHasher): PasswordHasherRegistry = {
    new PasswordHasherRegistry(passwordHasher)
  }

  @Provides
  def provideCredentialsProvider(
    authInfoRepository: AuthInfoRepository,
    passwordHasherRegistry: PasswordHasherRegistry): CredentialsProvider = {

    new CredentialsProvider(authInfoRepository, passwordHasherRegistry)
  }


  @Provides
  def provideAvatarService(httpLayer: HTTPLayer): AvatarService = new GravatarService(httpLayer)

}

你能帮我过来吗?

谢谢巴黎

推荐答案

你在这里混合了两种不同的东西.凭据提供程序不是请求提供程序.请求提供者是一种特殊类型的提供者，可以直接挂钩到请求中.详细说明可以在文档中找到.Silhouette 提供了一个 基本身份验证提供程序，它是请求提供程序的实现.

You mix two different things here. The credentials provider is not a request provider. A request provider is a special type of provider, which can be directly hooked into the request. A detailed description can be found in the documentation. Silhouette provides a Basic Authentication provider which is an implementation of a request provider.

凭据提供程序应直接注入您的控制器，如种子模板.

The credentials provider should directly injected into your controller as implemented in the seed template.

这篇关于使用剪影 4.0 播放 2.5 - 凭据提供程序的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！