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

import java.util.UUID

import com.mohiva.play.silhouette.api.LoginInfo
import com.mohiva.play.silhouette.api.services.IdentityService
import db.DbContext
import repositories.{UserPasswordInfo, User, UserLoginInfo, UserRepository}

import scala.concurrent.{ExecutionContext, Future}


class UserService(val ctx: DbContext)(implicit val ec: ExecutionContext) extends UserRepository with IdentityService[User] {
  import ctx._
  override def createUserWithRole(role: String): Future[UUID] = {
    val id = UUID.randomUUID()
    val created = java.time.LocalDateTime.now()
    run(users.insert(lift(User(id, role, created)))).map(_ => id)
  }

  override def createLoginInfo(userLoginInfo: UserLoginInfo): Future[UUID] = {
    run(loginInfos.insert(lift(userLoginInfo))).map(_ => userLoginInfo.userId)
  }

  override def createPasswordInfo(passwordInfo: UserPasswordInfo): Future[UUID] = {
    run(pwInfo.insert(lift(passwordInfo))).map(_ => passwordInfo.userId)
  }

  def findUserByProvideKey(providerKey: String): Future[Option[User]] = {
    run(findLoginInfoByProviderKey(providerKey))
      .map(_.headOption).flatMap {
        case Some(userLoginInfo) => run(byId(userLoginInfo.userId)).map(_.headOption)
        case None => Future(None)
      }
  }

  def retrieve(loginInfo: LoginInfo): Future[Option[User]] = findUserByProvideKey(loginInfo.providerKey)

} 

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

import javax.inject.Inject

import com.mohiva.play.silhouette.api.LoginInfo
import com.mohiva.play.silhouette.api.services.IdentityService
import models.ServiceProfile

import scala.concurrent.Future


class UserService @Inject() (userMicroServiceRegistry: UserMicroServiceRegistry) extends IdentityService[ServiceProfile] {
  override def retrieve(loginInfo: LoginInfo): Future[Option[ServiceProfile]] = userMicroServiceRegistry.getUserMicroService[ServiceProfile](loginInfo.providerID).map(_.retrieve(loginInfo)).getOrElse(Future.successful(None)) //Future.sequence(userMicroServiceRegistry.services.map {s => s.retrieve(loginInfo)}).map(_.flatten.headOption)
  def save[T <: ServiceProfile](profile: T): Future[T] = userMicroServiceRegistry.getUserMicroService[T](profile.service).map(_.save(profile)).getOrElse(Future.failed(new NoSuchElementException("None.get")))
}

case class UserMicroServiceRegistry @Inject() (services: Seq[UserMicroService[_]]) {
  def getUserMicroService[T <: ServiceProfile](tag: String): Option[UserMicroService[T]] = {
    println(s"$tag UserService.scala")
    services.foreach(s => println(s.tag))
    services.find(_.tag == tag).map(_.asInstanceOf[UserMicroService[T]])
  }
} 

//设置package包名称以及导入依赖的类
package org.intracer.finance.slick

import com.mohiva.play.silhouette.api.LoginInfo
import com.mohiva.play.silhouette.api.services.IdentityService
import org.intracer.finance.User
import play.api.libs.Codecs

class UserDao() extends BaseDao with IdentityService[User] {

  import driver.api._

  val query = TableQuery[Users]

  def insert(user: User): Int = run {
    query returning query.map(_.id) += user
  }

  def insertAll(users: Seq[User]): Unit = run {
    query.forceInsertAll(users)
  }

  def list: Seq[User] = run {
    query.sortBy(_.fullname).result
  }

  def count: Int = run {
    query.countDistinct.result
  }

  def byEmail(email: String): Option[User] = run {
    query.filter(_.email === email).result.headOption
  }

  def byId(id: Int): Option[User] = run {
    query.filter(_.id === id).result.headOption
  }

  def login(username: String, password: String): Option[User] = {
    byEmail(username).filter(user => {
      val passwordTrimmed = password.trim
      val inputHash = hash(user, passwordTrimmed)
      val dbHash = user.password.get
      inputHash == dbHash
    })
  }

  def hash(user: User, password: String): String =
    sha1(password)

  def sha1(input: String) = Codecs.sha1(input.getBytes)

  override def retrieve(loginInfo: LoginInfo) = {
    db.run {
      query
        .filter(_.email === loginInfo.providerKey)
        .result.headOption
    }
  }
} 

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

import benchq.Config
import benchq.model.User
import com.mohiva.play.silhouette.api.LoginInfo
import com.mohiva.play.silhouette.api.services.IdentityService

import scala.collection.mutable
import scala.concurrent.Future

class UserService(config: Config) extends IdentityService[User] {
  val users: mutable.HashMap[String, User] = mutable.HashMap.empty

  def retrieve(loginInfo: LoginInfo): Future[Option[User]] = {
    Future.successful(users.get(loginInfo.providerKey))
  }

  def save(profile: GithubProfile): Future[User] = {
    if (config.silhouette.allowedUsers(profile.login)) {
      val r = User(profile.id, profile.login, profile.name)
      users += profile.loginInfo.providerKey -> r
      Future.successful(r)
    } else
      Future.failed(UnauthorizedUserException(profile.login))
  }
}

case class UnauthorizedUserException(login: String)
    extends Exception(s"User $login is not authorized")