- Master is now compatible with Play 2.3. Use branch master-play.2.2.x for Play 2.2.

Author: jaliss

ChangeLog

@@ -1,4 +1,5 @@
 master  -
+		- Code is now compatible with Play 2.3
 		- Added SecureSocial.currentUser to support Websockets
 		- Fixed #429: null pointer exception in UserAware Java API (thanks @mangecoeur)
 		- Pull request #159: Weibo support (thanks @qiuzhanghua and @wuhaixing)

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

@@ -77,7 +77,7 @@ trait BaseLoginPage[U] extends SecureSocial[U]
       } yield {
         import ExecutionContext.Implicits.global
         redirectTo.discardingAuthenticator(authenticator).map {
-          _.withSession(Events.fire(new LogoutEvent(user)).getOrElse(session))
+          _.withSession(Events.fire(new LogoutEvent(user)).getOrElse(request.session))
         }
       }
       result.getOrElse {

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

@@ -128,7 +128,7 @@ trait BasePasswordChange[U] extends SecureSocial[U] {
         info =>  {
           val newPasswordInfo = env.currentHasher.hash(info.newPassword)
           import ExecutionContext.Implicits.global
-          implicit val userLang = lang(request)
+          implicit val userLang = request2lang(request)
           env.userService.updatePasswordInfo(request.user, newPasswordInfo).map {
             case Some(u) =>
               env.mailer.sendPasswordChangedNotice(u)(request, userLang)

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

@@ -16,18 +16,17 @@
  */
 package securesocial.controllers
 
-import securesocial.core._
-import play.api.mvc.Action
-import scala.concurrent.{Future, ExecutionContext}
-import securesocial.core.providers.UsernamePasswordProvider
-import play.api.i18n.Messages
 import play.api.data.Form
 import play.api.data.Forms._
+import play.api.i18n.Messages
+import play.api.mvc.Action
+import securesocial.core._
+import securesocial.core.providers.UsernamePasswordProvider
 import securesocial.core.providers.utils.PasswordValidator
-import securesocial.core.PasswordResetEvent
-import scala.Some
 import securesocial.core.services.SaveMode
 
+import scala.concurrent.Future
+
 /**
  * A default controller the uses the BasicProfile as the user type
  *
@@ -67,7 +66,7 @@ trait BasePasswordReset[U] extends MailTokenBasedOperations[U] {
    */
   def handleStartResetPassword = Action.async {
     implicit request =>
-      import ExecutionContext.Implicits.global
+      import scala.concurrent.ExecutionContext.Implicits.global
       startForm.bindFromRequest.fold(
         errors => Future.successful(BadRequest(env.viewTemplates.getStartResetPasswordPage(errors))),
         email => env.userService.findByEmailAndProvider(email, UsernamePasswordProvider.UsernamePassword).map {
@@ -105,7 +104,7 @@ trait BasePasswordReset[U] extends MailTokenBasedOperations[U] {
    * @param token the token that identifies the user request
    */
   def handleResetPassword(token: String) = Action.async { implicit request =>
-    import ExecutionContext.Implicits.global
+    import scala.concurrent.ExecutionContext.Implicits.global
     executeForToken(token, false, {
       t => changePasswordForm.bindFromRequest.fold(errors =>
           Future.successful(BadRequest(env.viewTemplates.getResetPasswordPage(errors, token))),
@@ -118,7 +117,7 @@ trait BasePasswordReset[U] extends MailTokenBasedOperations[U] {
                 deleted <- env.userService.deleteToken(token)
               ) yield {
                 env.mailer.sendPasswordChangedNotice(profile)
-                val eventSession = Events.fire(new PasswordResetEvent(updated)).getOrElse(session)
+                val eventSession = Events.fire(new PasswordResetEvent(updated)).getOrElse(request.session)
                 confirmationResult().withSession(eventSession).flashing(Success -> Messages(PasswordUpdated))
               }
             case _ =>

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

@@ -16,16 +16,16 @@
  */
 package securesocial.controllers
 
-import play.api.mvc._
+import play.api.Play
+import play.api.Play.current
 import play.api.i18n.Messages
+import play.api.mvc._
 import securesocial.core._
-import securesocial.core.utils._
-import play.api.Play
-import Play.current
-import scala.Some
-import scala.concurrent.{ExecutionContext, Future}
 import securesocial.core.authenticator.CookieAuthenticator
 import securesocial.core.services.SaveMode
+import securesocial.core.utils._
+
+import scala.concurrent.Future
 
 
 /**
@@ -41,7 +41,7 @@ class ProviderController(override implicit val env: RuntimeEnvironment[BasicProf
  */
 trait BaseProviderController[U] extends SecureSocial[U]
 {
-  import ProviderControllerHelper.{logger, toUrl}
+  import securesocial.controllers.ProviderControllerHelper.{logger, toUrl}
 
   /**
    * The authentication entry point for GET requests
@@ -89,9 +89,9 @@ trait BaseProviderController[U] extends SecureSocial[U]
    * @param redirectTo the url the user needs to be redirected to after being authenticated
    */
   private def handleAuth(provider: String, redirectTo: Option[String]) = UserAwareAction.async { implicit request =>
-    import ExecutionContext.Implicits.global
+    import scala.concurrent.ExecutionContext.Implicits.global
     val authenticationFlow = request.user.isEmpty
-    val modifiedSession = overrideOriginalUrl(session, redirectTo)
+    val modifiedSession = overrideOriginalUrl(request.session, redirectTo)
 
     env.providers.get(provider).map { _.authenticate().flatMap {
         case denied: AuthenticationResult.AccessDenied =>
@@ -112,8 +112,8 @@ trait BaseProviderController[U] extends SecureSocial[U]
               env.userService.save(authenticated.profile, mode).flatMap { userForAction =>
                 logger.debug(s"[securesocial] user completed authentication: provider = ${profile.providerId}, userId: ${profile.userId}, mode = $mode")
                 val evt = if (mode == SaveMode.LoggedIn) new LoginEvent(userForAction) else new SignUpEvent(userForAction)
-                val sessionAfterEvents = Events.fire(evt).getOrElse(session)
-                import ExecutionContext.Implicits.global
+                val sessionAfterEvents = Events.fire(evt).getOrElse(request.session)
+                import scala.concurrent.ExecutionContext.Implicits.global
                 builder().fromUser(userForAction).flatMap { authenticator =>
                   Redirect(toUrl(sessionAfterEvents)).withSession(sessionAfterEvents -
                     SecureSocial.OriginalUrlKey -

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

@@ -16,18 +16,18 @@
  */
 package securesocial.controllers
 
-import play.api.mvc.Action
-import play.api.data._
 import play.api.data.Forms._
-import securesocial.core.providers.UsernamePasswordProvider
-import securesocial.core._
-import securesocial.core.providers.utils._
+import play.api.data._
 import play.api.i18n.Messages
-import scala.Some
-import scala.concurrent.{ExecutionContext, Future, Await}
+import play.api.mvc.Action
+import securesocial.core._
 import securesocial.core.authenticator.CookieAuthenticator
+import securesocial.core.providers.UsernamePasswordProvider
+import securesocial.core.providers.utils._
 import securesocial.core.services.SaveMode
 
+import scala.concurrent.{Await, ExecutionContext, Future}
+
 
 /**
  * A default Registration controller that uses the BasicProfile as the user type
@@ -43,7 +43,7 @@ class Registration(override implicit val env: RuntimeEnvironment[BasicProfile])
  */
 trait BaseRegistration[U] extends MailTokenBasedOperations[U] {
 
-  import BaseRegistration._
+  import securesocial.controllers.BaseRegistration._
 
   private val logger = play.api.Logger("securesocial.controllers.Registration")
 
@@ -116,15 +116,15 @@ trait BaseRegistration[U] extends MailTokenBasedOperations[U] {
         e => {
           val email = e.toLowerCase
           // check if there is already an account for this email address
-          import ExecutionContext.Implicits.global
+          import scala.concurrent.ExecutionContext.Implicits.global
           env.userService.findByEmailAndProvider(email, UsernamePasswordProvider.UsernamePassword).map {
             maybeUser =>
               maybeUser match {
                 case Some(user) =>
                   // user signed up already, send an email offering to login/recover password
                   env.mailer.sendAlreadyRegisteredEmail(user)
                 case None =>
-                  import ExecutionContext.Implicits.global
+                  import scala.concurrent.ExecutionContext.Implicits.global
                   createToken(email, isSignUp = true).map { token =>
                       env.mailer.sendSignUpEmail(email, token.uuid)
                   }
@@ -153,7 +153,7 @@ trait BaseRegistration[U] extends MailTokenBasedOperations[U] {
    */
   def handleSignUp(token: String) = Action.async {
     implicit request =>
-      import ExecutionContext.Implicits.global
+      import scala.concurrent.ExecutionContext.Implicits.global
       executeForToken(token, true, {
         t =>
           form.bindFromRequest.fold(
@@ -189,7 +189,7 @@ trait BaseRegistration[U] extends MailTokenBasedOperations[U] {
               ) yield {
                 if (UsernamePasswordProvider.sendWelcomeEmail)
                   env.mailer.sendWelcomeEmail(newUser)
-                val eventSession = Events.fire(new SignUpEvent(saved)).getOrElse(session)
+                val eventSession = Events.fire(new SignUpEvent(saved)).getOrElse(request.session)
                 if (UsernamePasswordProvider.signupSkipLogin) {
                   env.authenticatorService.find(CookieAuthenticator.Id).map {
                     _.fromUser(saved).flatMap { authenticator =>

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

@@ -138,31 +138,31 @@ object ViewTemplates {
 
     override def getLoginPage(form: Form[(String, String)],
                               msg: Option[String] = None)(implicit request: RequestHeader, lang: Lang): Html = {
-      securesocial.views.html.login(form, msg)
+      securesocial.views.html.login(form, msg)(request, lang, env)
     }
 
     override def getSignUpPage(form: Form[RegistrationInfo], token: String)(implicit request: RequestHeader, lang: Lang): Html = {
-      securesocial.views.html.Registration.signUp(form, token)
+      securesocial.views.html.Registration.signUp(form, token)(request, lang, env)
     }
 
     override def getStartSignUpPage(form: Form[String])(implicit request: RequestHeader, lang: Lang): Html = {
-      securesocial.views.html.Registration.startSignUp(form)
+      securesocial.views.html.Registration.startSignUp(form)(request, lang, env)
     }
 
     override def getStartResetPasswordPage(form: Form[String])(implicit request: RequestHeader, lang: Lang): Html = {
-      securesocial.views.html.Registration.startResetPassword(form)
+      securesocial.views.html.Registration.startResetPassword(form)(request, lang, env)
     }
 
     override def getResetPasswordPage(form: Form[(String, String)], token: String)(implicit request: RequestHeader, lang: Lang): Html = {
-      securesocial.views.html.Registration.resetPasswordPage(form, token)
+      securesocial.views.html.Registration.resetPasswordPage(form, token)(request, lang, env)
     }
 
     override def getPasswordChangePage(form: Form[ChangeInfo])(implicit request: RequestHeader, lang: Lang): Html = {
-      securesocial.views.html.passwordChange(form)
+      securesocial.views.html.passwordChange(form)(request, lang, env)
     }
 
     def getNotAuthorizedPage(implicit request: RequestHeader, lang: Lang): Html = {
-      securesocial.views.html.notAuthorized()
+      securesocial.views.html.notAuthorized()(request, lang, env)
     }
   }
 }
@@ -174,27 +174,27 @@ object MailTemplates {
   class Default(env: RuntimeEnvironment[_]) extends MailTemplates {
     implicit val implicitEnv = env
     def getSignUpEmail(token: String)(implicit request: RequestHeader, lang: Lang): (Option[Txt], Option[Html]) = {
-      (None, Some(securesocial.views.html.mails.signUpEmail(token)))
+      (None, Some(securesocial.views.html.mails.signUpEmail(token)(request, lang)))
     }
 
     def getAlreadyRegisteredEmail(user: BasicProfile)(implicit request: RequestHeader, lang: Lang): (Option[Txt], Option[Html]) = {
-      (None, Some(securesocial.views.html.mails.alreadyRegisteredEmail(user)))
+      (None, Some(securesocial.views.html.mails.alreadyRegisteredEmail(user)(request, lang, env)))
     }
 
     def getWelcomeEmail(user: BasicProfile)(implicit request: RequestHeader, lang: Lang): (Option[Txt], Option[Html]) = {
-      (None, Some(securesocial.views.html.mails.welcomeEmail(user)))
+      (None, Some(securesocial.views.html.mails.welcomeEmail(user)(request, lang, env)))
     }
 
     def getUnknownEmailNotice()(implicit request: RequestHeader, lang: Lang): (Option[Txt], Option[Html]) = {
-      (None, Some(securesocial.views.html.mails.unknownEmailNotice()))
+      (None, Some(securesocial.views.html.mails.unknownEmailNotice()(request, lang)))
     }
 
     def getSendPasswordResetEmail(user: BasicProfile, token: String)(implicit request: RequestHeader, lang: Lang): (Option[Txt], Option[Html]) = {
-      (None, Some(securesocial.views.html.mails.passwordResetEmail(user, token)))
+      (None, Some(securesocial.views.html.mails.passwordResetEmail(user, token)(request, lang, env)))
     }
 
     def getPasswordChangedNoticeEmail(user: BasicProfile)(implicit request: RequestHeader, lang: Lang): (Option[Txt], Option[Html]) = {
-      (None, Some(securesocial.views.html.mails.passwordChangedNotice(user)))
+      (None, Some(securesocial.views.html.mails.passwordChangedNotice(user)(request, lang, env)))
     }
   }
 }

module-code/app/securesocial/core/SecureSocial.scala

@@ -45,15 +45,15 @@ trait SecureSocial[U] extends Controller {
    */
   protected val notAuthenticatedJson =  Unauthorized(Json.toJson(Map("error"->"Credentials required"))).as(JSON)
   protected val notAuthorizedJson = Forbidden(Json.toJson(Map("error" -> "Not authorized"))).as(JSON)
-  protected def notAuthorizedPage(): Html = securesocial.views.html.notAuthorized()
+  protected def notAuthorizedPage()(implicit request: RequestHeader): Html = securesocial.views.html.notAuthorized()
 
   protected def notAuthenticatedResult[A](implicit request: Request[A]): Future[SimpleResult] = {
     Future.successful {
       render  {
         case Accepts.Json() => notAuthenticatedJson
         case Accepts.Html() => Redirect(env.routes.loginPageUrl).
           flashing("error" -> Messages("securesocial.loginRequired"))
-          .withSession(session + (SecureSocial.OriginalUrlKey -> request.uri))
+          .withSession(request.session + (SecureSocial.OriginalUrlKey -> request.uri))
         case _ => Unauthorized("Credentials required")
       }
     }
@@ -132,7 +132,7 @@ trait SecureSocial[U] extends Controller {
       }
     }
 
-    override protected def invokeBlock[A](request: Request[A],
+    override def invokeBlock[A](request: Request[A],
                                           block: (SecuredRequest[A]) => Future[SimpleResult]): Future[SimpleResult] =
     {
       invokeSecuredBlock(authorize, request, block)
@@ -152,7 +152,7 @@ trait SecureSocial[U] extends Controller {
    * The UserAwareAction builder
    */
   class UserAwareActionBuilder extends ActionBuilder[({ type R[A] = RequestWithUser[A] })#R] {
-    protected def invokeBlock[A](request: Request[A],
+   override def invokeBlock[A](request: Request[A],
                                  block: (RequestWithUser[A]) => Future[SimpleResult]): Future[SimpleResult] =
     {
       import ExecutionContext.Implicits.global

module-code/app/securesocial/core/authenticator/StoreBackedAuthenticator.scala

@@ -17,6 +17,7 @@
 package securesocial.core.authenticator
 
 import org.joda.time.DateTime
+import scala.annotation.meta.getter
 import scala.concurrent.{ExecutionContext, Future}
 import play.api.mvc.SimpleResult
 
@@ -30,7 +31,7 @@ trait StoreBackedAuthenticator[U, T <: Authenticator[U]] extends Authenticator[U
   @transient
   protected val logger = play.api.Logger(this.getClass.getName)
 
-  @transient
+  @(transient @getter)
   val store: AuthenticatorStore[T]
 
   /**

module-code/app/securesocial/core/java/BasePasswordValidator.java

@@ -41,6 +41,6 @@ public abstract class BasePasswordValidator implements PasswordValidator {
      * @return
      */
     protected Tuple2<String, Seq<Object>> toScalaTuple(String message, List<Object> params) {
-        return new Tuple2<String, Seq<Object>>(message, JavaConverters.asScalaIterableConverter(params).asScala().toSeq());
+        return new Tuple2<String, Seq<Object>>(message, JavaConverters.collectionAsScalaIterableConverter(params).asScala().toSeq());
     }
 }

module-code/app/securesocial/core/java/DefaultSecuredActionResponses.java

@@ -17,12 +17,12 @@
 package securesocial.core.java;
 
 import com.fasterxml.jackson.databind.node.ObjectNode;
-import play.api.templates.Html;
 import play.libs.F;
 import play.libs.Json;
 import play.mvc.Controller;
 import play.mvc.Http;
-import play.mvc.SimpleResult;
+import play.mvc.Result;
+import play.twirl.api.Html;
 
 /**
  * The default responses sent when the invoker is not authenticated or authorized to execute a protected
@@ -32,12 +32,12 @@
  */
 public class DefaultSecuredActionResponses extends Controller implements SecuredActionResponses {
     public Html notAuthorizedPage(Http.Context ctx) {
-        return securesocial.views.html.notAuthorized.render(ctx.lang(), SecureSocial.env());
+        return securesocial.views.html.notAuthorized.render(ctx._requestHeader(), ctx.lang(), SecureSocial.env());
     }
 
-    public F.Promise<SimpleResult> notAuthenticatedResult(Http.Context ctx) {
+    public F.Promise<Result> notAuthenticatedResult(Http.Context ctx) {
         Http.Request req = ctx.request();
-        SimpleResult result;
+        Result result;
 
         if ( req.accepts("text/html")) {
             ctx.flash().put("error", play.i18n.Messages.get("securesocial.loginRequired"));
@@ -53,9 +53,9 @@ public F.Promise<SimpleResult> notAuthenticatedResult(Http.Context ctx) {
         return F.Promise.pure(result);
     }
 
-    public F.Promise<SimpleResult> notAuthorizedResult(Http.Context ctx) {
+    public F.Promise<Result> notAuthorizedResult(Http.Context ctx) {
         Http.Request req = ctx.request();
-        SimpleResult result;
+        Result result;
 
         if ( req.accepts("text/html")) {
             result = forbidden(notAuthorizedPage(ctx));