Migrate to Play 2.6

Author: gmethvin

securesocial.sbt build.sbt

@@ -3,6 +3,7 @@ name := "SecureSocial-parent"
 version := Common.version
 
 scalaVersion := Common.scalaVersion
+crossScalaVersions := Common.crossScalaVersions
 
 lazy val core =  project.in( file("module-code") ).enablePlugins(PlayScala)
 

module-code/app/securesocial/controllers/Assets.scala

@@ -1,3 +1,8 @@
 package securesocial.controllers
 
-class Assets extends controllers.AssetsBuilder(play.api.http.LazyHttpErrorHandler)
+import javax.inject.Inject
+
+import play.api.http.HttpErrorHandler
+
+class Assets @Inject() (errorHandler: HttpErrorHandler, metadata: controllers.AssetsMetadata)
+  extends controllers.AssetsBuilder(errorHandler, metadata)

module-code/app/securesocial/controllers/LoginApi.scala

@@ -19,25 +19,25 @@ package securesocial.controllers
 import javax.inject.Inject
 
 import org.joda.time.DateTime
-import securesocial.core._
-import play.api.mvc.Action
-import scala.concurrent.{ ExecutionContext, Future }
-import securesocial.core.SignUpEvent
+import play.api.mvc.ControllerComponents
 import securesocial.core.AuthenticationResult.Authenticated
-import securesocial.core.LoginEvent
-import securesocial.core.BasicProfile
 import securesocial.core.services.SaveMode
+import securesocial.core.{ LoginEvent, SignUpEvent, _ }
+
+import scala.concurrent.Future
 
 /**
  * A default controller that uses the BasicProfile as the application user type.
  */
-class LoginApi @Inject() (override implicit val env: RuntimeEnvironment) extends BaseLoginApi
+class LoginApi @Inject() (
+  override implicit val env: RuntimeEnvironment,
+  override val controllerComponents: ControllerComponents) extends BaseLoginApi
 
 /**
  * This trait provides the means to provide an authentication API that can be used by client side or mobile apps.
  *
  */
-trait BaseLoginApi extends SecureSocial {
+trait BaseLoginApi extends SecureSocialController {
 
   import play.api.libs.json._
 

module-code/app/securesocial/controllers/LoginPage.scala

@@ -18,20 +18,24 @@ package securesocial.controllers
 
 import javax.inject.Inject
 
+import play.api.mvc.ControllerComponents
 import securesocial.core._
 import securesocial.core.utils._
 import play.api.{ Configuration, Play }
 import providers.UsernamePasswordProvider
 
-import scala.concurrent.{ ExecutionContext, Future }
+import scala.concurrent.Future
 import play.filters.csrf.CSRFAddToken
 
 /**
  * A default Login controller that uses BasicProfile as the user type.
  *
  * @param env An environment
  */
-class LoginPage @Inject() (override implicit val env: RuntimeEnvironment, val csrfAddToken: CSRFAddToken) extends BaseLoginPage
+class LoginPage @Inject() (
+  override implicit val env: RuntimeEnvironment,
+  val csrfAddToken: CSRFAddToken,
+  val controllerComponents: ControllerComponents) extends BaseLoginPage
 
 /**
  * The trait that defines the login page controller
@@ -57,15 +61,15 @@ trait BaseLoginPage extends SecureSocial {
         // if the user is already logged in, a referer is set and we handle the
         // referer the same way as an OriginalUrl in the session, we redirect back
         // to this URL. Otherwise, just redirect to the application's landing page
-        val to = (if (SecureSocial.enableRefererAsOriginalUrl) {
+        val to = (if (env.enableRefererAsOriginalUrl.value) {
           SecureSocial.refererPathAndQuery
         } else {
           None
         }).getOrElse(ProviderControllerHelper.landingUrl(configuration))
         logger.debug("User already logged in, skipping login page. Redirecting to %s".format(to))
         Redirect(to)
       } else {
-        if (SecureSocial.enableRefererAsOriginalUrl) {
+        if (env.enableRefererAsOriginalUrl.value) {
           SecureSocial.withRefererAsOriginalUrl(Ok(env.viewTemplates.getLoginPage(UsernamePasswordProvider.loginForm)))
         } else {
           Ok(env.viewTemplates.getLoginPage(UsernamePasswordProvider.loginForm))
@@ -82,7 +86,7 @@ trait BaseLoginPage extends SecureSocial {
    */
   def logout = UserAwareAction.async {
     implicit request =>
-      val redirectTo = Redirect(configuration.getString(onLogoutGoTo).getOrElse(env.routes.loginPageUrl))
+      val redirectTo = Redirect(configuration.get[Option[String]](onLogoutGoTo).getOrElse(env.routes.loginPageUrl))
       val result = for {
         user <- request.user
         authenticator <- request.authenticator

module-code/app/securesocial/controllers/MailTokenBasedOperations.scala

@@ -23,7 +23,7 @@ import play.api.Configuration
 import play.api.data.Form
 import play.api.data.Forms._
 import play.api.data.validation.Constraints._
-import play.api.i18n.{ I18nSupport, Messages, MessagesApi }
+import play.api.i18n.Messages
 import play.api.mvc.{ RequestHeader, Result }
 import securesocial.core.SecureSocial
 import securesocial.core.providers.MailToken
@@ -34,19 +34,16 @@ import scala.concurrent.Future
  * The base controller for password reset and password change operations
  *
  */
-abstract class MailTokenBasedOperations extends SecureSocial with I18nSupport {
+abstract class MailTokenBasedOperations extends SecureSocial {
   val Success = "success"
   val Error = "error"
   val Email = "email"
   val TokenDurationKey = "securesocial.userpass.tokenDuration"
-  val DefaultDuration = 60
   val configuration: Configuration = env.configuration
-  val TokenDuration = configuration.getInt(TokenDurationKey).getOrElse(DefaultDuration)
-  implicit val messagesApi: MessagesApi = env.messagesApi
+  val TokenDuration = configuration.get[Int](TokenDurationKey)
 
   val startForm = Form(
-    Email -> email.verifying(nonEmpty)
-  )
+    Email -> email.verifying(nonEmpty))
 
   /**
    * Creates a token for mail based operations
@@ -59,8 +56,7 @@ abstract class MailTokenBasedOperations extends SecureSocial with I18nSupport {
     val now = DateTime.now
 
     Future.successful(MailToken(
-      UUID.randomUUID().toString, email.toLowerCase, now, now.plusMinutes(TokenDuration), isSignUp = isSignUp
-    ))
+      UUID.randomUUID().toString, email.toLowerCase, now, now.plusMinutes(TokenDuration), isSignUp = isSignUp))
   }
 
   /**

module-code/app/securesocial/controllers/PasswordChange.scala

@@ -18,17 +18,17 @@ package securesocial.controllers
 
 import javax.inject.Inject
 
-import securesocial.core._
-import securesocial.core.SecureSocial._
-import play.api.mvc.Result
-import play.api.{ Configuration, Play }
+import play.api.Configuration
 import play.api.data.Form
 import play.api.data.Forms._
+import play.api.i18n.{ I18nSupport, Messages }
+import play.api.mvc.{ ControllerComponents, Result }
+import play.filters.csrf._
+import securesocial.core.SecureSocial._
+import securesocial.core._
 import securesocial.core.providers.utils.PasswordValidator
-import play.api.i18n.{ I18nSupport, Messages, MessagesApi }
 
 import scala.concurrent.{ Await, Future }
-import play.filters.csrf._
 
 /**
  * A default PasswordChange controller that uses the BasicProfile as the user type
@@ -38,8 +38,8 @@ import play.filters.csrf._
 class PasswordChange @Inject() (
   override implicit val env: RuntimeEnvironment,
   val csrfAddToken: CSRFAddToken,
-  val csrfCheck: CSRFCheck
-) extends BasePasswordChange
+  val csrfCheck: CSRFCheck,
+  val controllerComponents: ControllerComponents) extends BasePasswordChange
 
 /**
  * A trait that defines the password change functionality
@@ -58,17 +58,15 @@ trait BasePasswordChange extends SecureSocial with I18nSupport {
   val csrfAddToken: CSRFAddToken
   val csrfCheck: CSRFCheck
   val configuration: Configuration = env.configuration
-  implicit val messagesApi: MessagesApi = env.messagesApi
 
   /**
    * The property that specifies the page the user is redirected to after changing the password.
    */
   val onPasswordChangeGoTo = "securesocial.onPasswordChangeGoTo"
 
   /** The redirect target of the handlePasswordChange action. */
-  def onHandlePasswordChangeGoTo = configuration.getString(onPasswordChangeGoTo).getOrElse(
-    securesocial.controllers.routes.PasswordChange.page().url
-  )
+  def onHandlePasswordChangeGoTo = configuration.get[Option[String]](onPasswordChangeGoTo).getOrElse(
+    securesocial.controllers.routes.PasswordChange.page().url)
 
   /**
    * checks if the supplied password matches the stored one
@@ -98,11 +96,7 @@ trait BasePasswordChange extends SecureSocial with I18nSupport {
         NewPassword ->
           tuple(
             Password1 -> nonEmptyText.verifying(PasswordValidator.constraint),
-            Password2 -> nonEmptyText
-          ).verifying(Messages(BaseRegistration.PasswordsDoNotMatch), passwords => passwords._1 == passwords._2)
-
-      )((currentPassword, newPassword) => ChangeInfo(currentPassword, newPassword._1))((changeInfo: ChangeInfo) => Some(("", ("", ""))))
-    )
+            Password2 -> nonEmptyText).verifying(Messages(BaseRegistration.PasswordsDoNotMatch), passwords => passwords._1 == passwords._2))((currentPassword, newPassword) => ChangeInfo(currentPassword, newPassword._1))((changeInfo: ChangeInfo) => Some(("", ("", "")))))
 
     env.userService.passwordInfoFor(request.user).flatMap {
       case Some(info) =>
@@ -139,17 +133,15 @@ trait BasePasswordChange extends SecureSocial with I18nSupport {
           errors => Future.successful(BadRequest(env.viewTemplates.getPasswordChangePage(errors))),
           info => {
             val newPasswordInfo = env.currentHasher.hash(info.newPassword)
-            val userLang = request2lang(request)
             env.userService.updatePasswordInfo(request.user, newPasswordInfo).map {
               case Some(u) =>
-                env.mailer.sendPasswordChangedNotice(u)(request, userLang)
+                env.mailer.sendPasswordChangedNotice(u)(request, messagesApi.preferred(request))
                 val result = Redirect(onHandlePasswordChangeGoTo).flashing(Success -> Messages(OkMessage))
                 Events.fire(PasswordChangeEvent(request.user)).map(result.withSession).getOrElse(result)
               case None =>
                 Redirect(onHandlePasswordChangeGoTo).flashing(Error -> Messages("securesocial.password.error"))
             }
-          }
-        )
+          })
       }
     }
   }

module-code/app/securesocial/controllers/PasswordReset.scala

@@ -18,12 +18,11 @@ package securesocial.controllers
 
 import javax.inject.Inject
 
-import play.api.Configuration
 import play.api.data.Form
 import play.api.data.Forms._
 import play.api.i18n.{ Messages, MessagesApi }
+import play.api.mvc._
 import play.filters.csrf._
-import play.api.mvc.Action
 import securesocial.core._
 import securesocial.core.providers.UsernamePasswordProvider
 import securesocial.core.providers.utils.PasswordValidator
@@ -39,29 +38,28 @@ import scala.concurrent.Future
 class PasswordReset @Inject() (
   override implicit val env: RuntimeEnvironment,
   val csrfAddToken: CSRFAddToken,
-  val csrfCheck: CSRFCheck
-) extends BasePasswordReset
+  val csrfCheck: CSRFCheck,
+  val controllerComponents: ControllerComponents) extends BasePasswordReset
 
 /**
  * The trait that provides the Password Reset functionality
  *
  */
-trait BasePasswordReset extends MailTokenBasedOperations {
+trait BasePasswordReset extends MailTokenBasedOperations with BaseController {
   private val logger = play.api.Logger("securesocial.controllers.BasePasswordReset")
 
   val PasswordUpdated = "securesocial.password.passwordUpdated"
   val ErrorUpdatingPassword = "securesocial.password.error"
 
-  val changePasswordForm = Form(
+  def changePasswordForm(implicit request: RequestHeader) = Form(
     BaseRegistration.Password ->
       tuple(
         BaseRegistration.Password1 -> nonEmptyText.verifying(PasswordValidator.constraint),
-        BaseRegistration.Password2 -> nonEmptyText
-      ).verifying(Messages(BaseRegistration.PasswordsDoNotMatch), passwords => passwords._1 == passwords._2)
-  )
+        BaseRegistration.Password2 -> nonEmptyText).verifying(Messages(BaseRegistration.PasswordsDoNotMatch), passwords => passwords._1 == passwords._2))
 
-  val csrfAddToken: CSRFAddToken
-  val csrfCheck: CSRFCheck
+  def csrfAddToken: CSRFAddToken
+  def csrfCheck: CSRFCheck
+  override def messagesApi: MessagesApi = super.messagesApi
 
   /**
    * Renders the page that starts the password reset flow
@@ -96,8 +94,7 @@ trait BasePasswordReset extends MailTokenBasedOperations {
                 }
                 handleStartResult().flashing(Success -> Messages(BaseRegistration.ThankYouCheckEmail))
             }
-          }
-        )
+          })
     }
   }
 
@@ -123,7 +120,6 @@ trait BasePasswordReset extends MailTokenBasedOperations {
    */
   def handleResetPassword(token: String) = csrfCheck {
     Action.async { implicit request =>
-      import scala.concurrent.ExecutionContext.Implicits.global
       executeForToken(token, false, {
         t =>
           changePasswordForm.bindFromRequest.fold(
@@ -144,8 +140,7 @@ trait BasePasswordReset extends MailTokenBasedOperations {
                 case _ =>
                   logger.error("[securesocial] could not find user with email %s during password reset".format(t.email))
                   Future.successful(confirmationResult().flashing(Error -> Messages(ErrorUpdatingPassword)))
-              }
-          )
+              })
       })
     }
   }

module-code/app/securesocial/controllers/ProviderController.scala

@@ -19,7 +19,7 @@ package securesocial.controllers
 import javax.inject.Inject
 
 import play.api.Configuration
-import play.api.i18n.{ I18nSupport, Messages, MessagesApi }
+import play.api.i18n.{ I18nSupport, Messages }
 import play.api.mvc._
 import securesocial.core._
 import securesocial.core.authenticator.CookieAuthenticator
@@ -43,7 +43,6 @@ trait BaseProviderController extends SecureSocial with I18nSupport {
   val logger = play.api.Logger(this.getClass.getName)
 
   val configuration: Configuration = env.configuration
-  implicit val messagesApi: MessagesApi = env.messagesApi
 
   /**
    * The authentication entry point for GET requests
@@ -168,16 +167,15 @@ object ProviderControllerHelper {
   /**
    * The application context
    */
-  val ApplicationContext = "application.context"
+  val ApplicationContext = "play.http.context"
 
   /**
    * The url where the user needs to be redirected after succesful authentication.
    *
    * @return
    */
-  def landingUrl(configuration: Configuration) = configuration.getString(onLoginGoTo).getOrElse(
-    configuration.getString(ApplicationContext).getOrElse(Root)
-  )
+  def landingUrl(configuration: Configuration) = configuration.get[Option[String]](onLoginGoTo).getOrElse(
+    configuration.get[String](ApplicationContext))
 
   /**
    * Returns the url that the user should be redirected to after login