first version of authentication support

package controllers

import javax.inject.{Inject, Singleton}

import akka.actor.ActorSystem

import controllers.auth.{AuthAction, AuthenticationModule}

import forms.LoginForm

import play.api.mvc.{Action, Controller}

@Singleton

class AuthController @Inject()(system: ActorSystem, authentication: AuthenticationModule) extends Controller {

  import AuthController._

  private val badFormMsg = "invalid login form data"

  def index = Action { implicit request =>

    if (authentication.isEnabled) {

      request.session.get(AuthAction.SESSION_USER).map { user =>

        request.session.get(AuthAction.REDIRECT_URL) match {

          case Some(url) =>

            Redirect(url, play.api.http.Status.SEE_OTHER)

          case None =>

            Redirect(routes.Application.index())

        }

      }.getOrElse {

        Ok(views.html.auth.login())

      }

    } else {

      Redirect(routes.Application.index())

    }

  }

  def login = Action { implicit request =>

    LoginForm.form.bindFromRequest.fold(

      formWithErrors => {

        log.error(badFormMsg)

        BadRequest(badFormMsg)

      },

      creds => {

        authentication.authentication(creds.user, creds.password) match {

          case Some(username) =>

            val resp =

              request.session.get(AuthAction.REDIRECT_URL) match {

                case Some(url) => Redirect(url, play.api.http.Status.SEE_OTHER)

                case None => Redirect(routes.Application.index())

              }

            resp.withSession(AuthAction.SESSION_USER -> username)

          case None =>

            Redirect(routes.AuthController.index).flashing(LOGIN_MSG -> "wrong user and/or password")

        }

      }

    )

  }

  def logout = Action {

    request =>

      Redirect("/login").withNewSession

  }

}

object AuthController {

  private val log = org.slf4j.LoggerFactory.getLogger(classOf[AuthController])

  final val LOGIN_MSG = "login-msg"

}

package controllers

import controllers.auth.{AuthAction, AuthenticationModule}

import play.api.mvc.Controller

trait AuthSupport { self: Controller =>

  def AuthAction(authentication: AuthenticationModule): AuthAction =

    new AuthAction(authentication)

}

 No newline at end of file

package controllers.auth

import controllers.routes

import play.api.mvc._

import scala.concurrent.Future

class AuthRequest[A](val username: String, request: Request[A]) extends WrappedRequest[A](request)

final class AuthAction(auth: AuthenticationModule) extends ActionBuilder[AuthRequest] {

  def invokeBlock[A](request: Request[A], block: (AuthRequest[A]) => Future[Result]) = {

    if (auth.isEnabled) {

      request.session.get(AuthAction.SESSION_USER).map { username =>

        block(new AuthRequest(username, request))

      }.getOrElse {

        Future.successful(

          Results.Redirect(routes.AuthController.index).

            withSession(AuthAction.REDIRECT_URL -> request.uri))

      }

    } else {

      block(new AuthRequest("guest", request))

    }

  }

}

object AuthAction {

  private[controllers] val SESSION_USER = "username"

  private[controllers] val REDIRECT_URL = "redirect"

}

 No newline at end of file

package controllers.auth

import play.api.Configuration

trait AuthConfig {

  def getSetting(setting: String)(implicit config: Configuration) = {

    config.getString(setting).getOrElse(throw MissingSettingException(setting))

  }

}

package controllers.auth

trait AuthService {

  def auth(username: String, password: String): Option[String]

}