//设置package包名称以及导入依赖的类
package co.horn.alkes.auth
import akka.http.scaladsl.model.{HttpResponse, StatusCodes}
import akka.http.scaladsl.server.directives.Credentials

import scala.concurrent.Future
import scala.util.Random


class NoAuthority extends Authority {
  lazy val anonymous = new Random(1337L)

  def ping: Future[HttpResponse] = Future.successful(HttpResponse(StatusCodes.OK))

  def channelAccess(credentials: Credentials, channel_uuid: String): Future[Option[Long]] = {
    Future.successful(Some(anonymous.nextLong))
  }

  def overlordAccess(credentials: Credentials): Future[Option[Long]] = {
    Future.successful(Some(anonymous.nextLong))
  }
} 

//设置package包名称以及导入依赖的类
package org.nephtys.keepaseat.internal.configs

import akka.http.scaladsl.server.{Directive, Route}
import akka.http.scaladsl.server.Directives.authenticateBasic
import akka.http.scaladsl.server.directives.Credentials


object Authenticators {

  def normalUserOrSuperuserAuthenticator(config : PasswordConfig)(credentials : Credentials) : Option[String] = {
    credentials match {
      case p @ Credentials.Provided(id) if (id == config.normalUser.username && p.verify(config.normalUser.password)
        ) || (id == config.superUser.username && p.verify(config.superUser.password)
        ) => Some(id)
      case _ => None
    }
  }

  def onlySuperuserAuthenticator(config : PasswordConfig)(credentials : Credentials) : Option[String] = {
    credentials match {
      case p @ Credentials.Provided(id) if id == config.superUser.username && p.verify(config.superUser.password) => Some(id)
      case _ => None
    }
  }

  def BasicAuthOrPass(passwordConfig : PasswordConfig, onlySuperusers : Boolean)(routeInner : () => Route) : Route = {
    if (passwordConfig.hasPasswords) {
      authenticateBasic(passwordConfig.realmForCredentials, if(onlySuperusers) onlySuperuserAuthenticator(passwordConfig) else normalUserOrSuperuserAuthenticator
      (passwordConfig)) {
        username => routeInner.apply()
      }
    } else {
      routeInner.apply()
    }

  }
} 

//设置package包名称以及导入依赖的类
package shine.st.blog.handler

import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.server.directives.Credentials
import pdi.jwt.{Jwt, JwtAlgorithm, JwtClaim}
import shine.st.blog.api.tokenKey
import shine.st.blog.dao.ManagerCollectionDao
import shine.st.blog.protocol.document.Manager
import shine.st.blog.protocol.input.TokenHeader
import spray.json.JsonParser


trait AuthenticationHandler {


  def createToken(secretKey: String, id: String): String = {
    val jwtClaim = JwtClaim(s"""{"id": "$id"}""").issuedNow.expiresIn(60 * 60 * 6)
    Jwt.encode(jwtClaim, tokenKey, JwtAlgorithm.HS256)
  }


  def authenticator(key: String): Credentials => Option[Manager] =
    credentials =>
      credentials match {
        case [email protected](token) =>
          Jwt.validate(token, key, Seq(JwtAlgorithm.HS256))
          val res0 = Jwt.decodeRaw(token, key, Seq(JwtAlgorithm.HS256))

          val json = JsonParser(res0.toOption.get)
          val tokenHeader = json.convertTo[TokenHeader]
          ManagerCollectionDao.findById(tokenHeader.id)

        case _ => None
      }


  def authenticate(tokenKey: String) =
    authenticateOAuth2("", authenticator(tokenKey))
} 

//设置package包名称以及导入依赖的类
package pl.touk.nussknacker.ui.security

import java.io.File

import akka.http.scaladsl.server.directives.Credentials.Provided
import akka.http.scaladsl.server.directives.{Credentials, SecurityDirectives}
import com.typesafe.config.ConfigFactory
import net.ceedubs.ficus.Ficus._
import net.ceedubs.ficus.readers.ArbitraryTypeReader._
import pl.touk.nussknacker.ui.security.Permission.Permission
import net.ceedubs.ficus.readers.EnumerationReader._

class SimpleAuthenticator(path: String) extends SecurityDirectives.Authenticator[LoggedUser] {

  //TODO: config reload
  val users = prepareUsers()

  def prepareUsers() : Map[String, LoggedUser] = {
    val config = ConfigFactory.parseFile(new File(path))
    config.as[List[LoggedUser]]("users").map(u => u.id -> u).toMap
  }

  override def apply(credentials: Credentials) = credentials match {
    case [email protected](id) => users.get(id).filter(u => d.verify(u.password))
    case _ => None
  }
}

case class LoggedUser(id: String, password: String, permissions: List[Permission],
                      categories: List[String]) {
  def hasPermission(permission: Permission) = {
    permissions.contains(permission) || isAdmin
  }

  def isAdmin = permissions.contains(Permission.Admin)
}

object Permission extends Enumeration {
  type Permission = Value
  val Read, Write, Deploy, Admin = Value
} 

//设置package包名称以及导入依赖的类
package com.wlangiewicz.workouttracker.api

import akka.actor.ActorSystem
import akka.http.scaladsl.model.HttpResponse
import akka.http.scaladsl.model.StatusCodes._
import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.server._
import akka.http.scaladsl.server.directives.Credentials
import com.wlangiewicz.workouttracker.domain.{ApiKey, User}

import scala.concurrent.ExecutionContextExecutor

trait Api extends RouteConcatenation with UserApi with WorkoutApi with ReportApi {
  implicit val system: ActorSystem

  implicit def exceptionHandler: ExceptionHandler =
    ExceptionHandler {
      case _: ApiException =>
        extractUri { uri =>
          complete(HttpResponse(BadRequest, entity = "invalid request"))
        }
    }

  val routes =
    Route.seal {
      userApiRoutes ~ workoutApiRoutes ~ reportApiRoutes
    }

  implicit def executor: ExecutionContextExecutor

  def apiAuthentication(credentials: Credentials): Option[User] =
    credentials match {
      case p @ Credentials.Provided(id) => userDao.findByApiKey(ApiKey(id))
      case Credentials.Missing          => None
      case _                            => None
    }

}

class ApiException(val message: String) extends RuntimeException(message) 

//设置package包名称以及导入依赖的类
package de.tu_berlin.formic.example

import akka.actor.ActorSystem
import akka.event.{LogSource, Logging}
import akka.http.scaladsl.server.directives.Credentials
import akka.http.scaladsl.server.directives.Credentials.{Missing, Provided}


class UniqueUsernameAuthenticator(actorSystem: ActorSystem) {

  private var usernames: Set[String] = Set.empty

  val log = Logging.getLogger(actorSystem, this)

  def authenticate(creds: Credentials): Option[String] = {
    log.debug(s"Client trying to connect with credentials: $creds")
    creds match {
      case Provided(identifier) =>
        if (usernames.contains(identifier)) {
          log.warning(s"Rejecting user $identifier because of duplicated username")
          Option.empty
        }
        else {
          usernames = usernames + identifier
          Option(identifier)
        }
      case Missing =>
        log.warning(s"Rejecting connection because of missing credentials")
        Option.empty
    }
  }
}

object UniqueUsernameAuthenticator {
  def apply(actorSystem: ActorSystem): UniqueUsernameAuthenticator = new UniqueUsernameAuthenticator(actorSystem)
} 

//设置package包名称以及导入依赖的类
package de.tu_berlin.formic.example

import akka.actor.ActorSystem
import akka.http.scaladsl.model.headers.BasicHttpCredentials
import akka.http.scaladsl.server.directives.Credentials
import akka.testkit.TestKit
import org.scalatest.{BeforeAndAfterAll, FlatSpec, FlatSpecLike, Matchers}


class UniqueUsernameAuthenticatorSpec extends TestKit(ActorSystem("UniqueUsernameAuthenticatorSpec")) with FlatSpecLike with Matchers with BeforeAndAfterAll{

  "UniqueUserNameAuthenticator" should "accept new usernames" in {
    val authenticator = UniqueUsernameAuthenticator(system)
    val username = "UniqueUserNameAuthenticator"
    val auth = authenticator.authenticate(Credentials(Option(BasicHttpCredentials(username, ""))))
    val username2 = "UniqueUserNameAuthenticator1"
    val auth2 = authenticator.authenticate(Credentials(Option(BasicHttpCredentials(username2, ""))))
    val username3 = "UniqueUserNameAuthenticator2"
    val auth3 = authenticator.authenticate(Credentials(Option(BasicHttpCredentials(username3, ""))))

    auth should equal(Option(username))
    auth2 should equal(Option(username2))
    auth3 should equal(Option(username3))
  }

  it should "reject missing credentials" in {
    val authenticator = UniqueUsernameAuthenticator(system)
    val auth = authenticator.authenticate(Credentials(Option.empty))

    auth should equal(None)
  }
  it should "reject duplicate usernames" in {
    val authenticator = UniqueUsernameAuthenticator(system)
    val username = "duplicate"
    authenticator.authenticate(Credentials(Option(BasicHttpCredentials(username, ""))))
    val auth = authenticator.authenticate(Credentials(Option(BasicHttpCredentials(username, ""))))

    auth should equal(None)
  }

}