Merge branch 'release/0.2.15.8'

.gitattributes

@@ -0,0 +1 @@
+public/bower_components/* linguist-vendored

activator

@@ -288,7 +288,7 @@ declare -a java_args
 declare -a app_commands
 declare -r real_script_path="$(realpath "$0")"
 declare -r activator_home="$(realpath "$(dirname "$real_script_path")")"
-declare -r app_version="1.3.2"
+declare -r app_version="1.3.6"
 
 declare -r app_launcher="${activator_home}/activator-launch-${app_version}.jar"
 declare -r script_name=activator

app/Filters.scala

@@ -0,0 +1,19 @@
+import javax.inject.Inject
+
+import com.mohiva.play.htmlcompressor.HTMLCompressorFilter
+import com.mohiva.play.xmlcompressor.XMLCompressorFilter
+import play.api.http.HttpFilters
+import play.api.mvc.EssentialFilter
+
+/**
+ * Filters for HTML Compressor
+ * Created by ediaz on 11-10-15.
+ */
+class Filters @Inject() (htmlCompressorFilter: HTMLCompressorFilter, xmlCompressorFilter: XMLCompressorFilter)
+  extends HttpFilters {
+
+  override def filters: Seq[EssentialFilter] = Seq(
+    htmlCompressorFilter,
+    xmlCompressorFilter
+  )
+}

app/controllers/Application.scala

@@ -1,17 +1,22 @@
 package controllers
 
+import javax.inject.Inject
 import jp.t2v.lab.play2.auth.OptionalAuthElement
-import models.Guest
-import play.api.mvc._
-import services.PostService
+import models.{Posts, Guest}
+import play.api.i18n.{I18nSupport, MessagesApi}
+import play.api.mvc.Controller
+import play.api.db.slick.DatabaseConfigProvider
 import scala.concurrent.Future
+import scala.concurrent.ExecutionContext.Implicits.global
 
-object Application extends Controller with DBElement  with OptionalAuthElement with AuthConfigImpl {
+class Application @Inject()(val messagesApi:MessagesApi, dbConfigProvider:DatabaseConfigProvider) extends Controller  with OptionalAuthElement with AuthConfigImpl with I18nSupport {
 
   val MAX_POSTS = 10
 
   def index = AsyncStack { implicit request =>
-    Future.successful(Ok(views.html.index("Prosa",  PostService.last(MAX_POSTS), loggedIn.getOrElse(Guest))))
+    Posts.last(MAX_POSTS).map { posts =>
+      Ok(views.html.index("Prosa", posts, loggedIn.getOrElse(Guest)))
+    }
   }
 
   def untrail(path: String) = AsyncStack { implicit request =>

app/controllers/AuthConfigImpl.scala

@@ -2,12 +2,8 @@ package controllers
 
 import jp.t2v.lab.play2.auth.{CookieTokenAccessor, AuthConfig}
 import models._
-import play.api.Play.current
-import play.api.db.slick.DB
 import play.api.mvc.Results._
 import play.api.mvc._
-import services.AuthorService
-
 import scala.concurrent.{ExecutionContext, Future}
 import scala.reflect.{ClassTag, classTag}
 
@@ -21,11 +17,8 @@ trait AuthConfigImpl extends AuthConfig {
 
   val sessionTimeoutInSeconds = 3600
 
-  def resolveUser(id:Id)(implicit ctx:ExecutionContext) : Future[Option[User]] = Future {
-    DB.withSession { implicit session =>
-        AuthorService.findById(id)
-    }
-  }
+  def resolveUser(id:Id)(implicit ctx:ExecutionContext) : Future[Option[User]] =
+        Authors.findById(id)
 
   def loginSucceeded(request:RequestHeader)(implicit ctx:ExecutionContext) : Future[Result] =  {
     val uri = request.session.get("access_uri").getOrElse(routes.BlogsGuestController.index().url.toString)
@@ -37,7 +30,9 @@ trait AuthConfigImpl extends AuthConfig {
   def authenticationFailed(request:RequestHeader)(implicit ctx:ExecutionContext) : Future[Result] =
     Future.successful(Redirect(routes.AuthController.login()).withSession("access_uri" -> request.uri))
 
-  def authorizationFailed(request:RequestHeader)(implicit ctx:ExecutionContext) = Future(Redirect(routes.AuthController.login()))
+  override def authorizationFailed(request:RequestHeader, user: User, authority: Option[Authority])(implicit ctx:ExecutionContext) = {
+    Future(Redirect(routes.AuthController.login()))
+  }
 
   def authorize(user:User, authority:Authority)(implicit ctx:ExecutionContext) = Future.successful((Permission.valueOf(user.permission), authority) match {
     case (Administrator, _) => true

app/controllers/AuthController.scala

@@ -1,35 +1,26 @@
 package controllers
 
+import javax.inject.Inject
+
 import jp.t2v.lab.play2.auth.LoginLogout
-import models.Author
-import org.mindrot.jbcrypt.BCrypt
-import play.api.Play.current
+import models.Authors
 import play.api.data.Form
 import play.api.data.Forms._
+import play.api.db.slick.DatabaseConfigProvider
+import play.api.i18n.{I18nSupport, MessagesApi}
 import play.api.mvc.{Action, Controller}
-import services.AuthorService
-
+import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.Future
 
+case class LoginData(username:String, password:String)
 
-object AuthController extends Controller with LoginLogout with AuthConfigImpl {
-  import scala.concurrent.ExecutionContext.Implicits.global
+class AuthController @Inject() (val messagesApi: MessagesApi, dbConfigProvider: DatabaseConfigProvider) extends Controller with LoginLogout with AuthConfigImpl with I18nSupport {
 
-  val loginForm = Form {
-    mapping("nickname" -> nonEmptyText, "password" -> text)(authenticateAuthor)(_.map(u => (u.nickname, "")))
-      .verifying("Invalid email or password", result => result.isDefined)
-  }
 
-  def authenticateAuthor(nickname:String, password:String) : Option[Author] = {
-    play.api.db.slick.DB.withSession { implicit session =>
-      AuthorService.findByNickname(nickname).flatMap { author =>
-        if (BCrypt.checkpw(password, author.password))
-          Some(author)
-        else
-          None
-      }
-    }
-  }
+  val loginForm = Form(
+    mapping("nickname" -> nonEmptyText, "password" -> text
+    ) (LoginData.apply)(LoginData.unapply)
+  )
 
   def login = Action { implicit request =>
     Ok(views.html.login(loginForm))
@@ -42,7 +33,11 @@ object AuthController extends Controller with LoginLogout with AuthConfigImpl {
   def authenticate = Action.async { implicit request =>
     loginForm.bindFromRequest.fold(
       formWithErrors => Future.successful(BadRequest(views.html.login(formWithErrors))),
-      author => gotoLoginSucceeded(author.get.id)
+      data =>
+        Authors.authenticate(data.username, data.password).flatMap {
+          case Some(user) => gotoLoginSucceeded(user.id)
+          case None => Future.successful(BadRequest(views.html.login(loginForm.fill(data).withGlobalError("user.not_authenticated"))))
+        }
     )
   }
 

app/controllers/AuthorsController.scala

@@ -1,15 +1,16 @@
 package controllers
 
+import javax.inject.Inject
 import jp.t2v.lab.play2.auth.AuthElement
-import models.Writer
+import models.{Authors, Writer}
 import org.mindrot.jbcrypt.BCrypt
 import play.api.data.Form
 import play.api.data.Forms._
-import play.api.i18n.Messages
+import play.api.db.slick.DatabaseConfigProvider
+import play.api.i18n.{I18nSupport, MessagesApi, Messages}
 import play.api.mvc.Controller
-import services.AuthorService
 
-object AuthorsController extends Controller with DBElement  with TokenValidateElement with AuthElement with AuthConfigImpl {
+class AuthorsController @Inject() (val messagesApi: MessagesApi, dbConfigProvider: DatabaseConfigProvider) extends Controller with TokenValidateElement with AuthElement with AuthConfigImpl with I18nSupport  {
 
   val changePasswordForm = Form(
     tuple(
@@ -22,20 +23,20 @@ object AuthorsController extends Controller with DBElement  with TokenValidateEl
     )
   )
 
-  def changePassword = StackAction(AuthorityKey -> Writer,IgnoreTokenValidation -> None) { implicit request =>
+  def changePassword() = StackAction(AuthorityKey -> Writer,IgnoreTokenValidation -> None) { implicit request =>
     Ok(views.html.change_password(changePasswordForm))
   }
 
 
-  def savePassword = StackAction(AuthorityKey -> Writer) { implicit request =>
+  def savePassword() = StackAction(AuthorityKey -> Writer) { implicit request =>
     changePasswordForm.bindFromRequest.fold(
       formWithErrors => BadRequest(views.html.change_password(formWithErrors)),
       formOk => {
         val (password, new_password, _) = formOk
         if (!BCrypt.checkpw(password, loggedIn.password))
           BadRequest(views.html.change_password(changePasswordForm.withError("password", "main.error.bad_current_password")))
         else {
-          AuthorService.changePassword(loggedIn, new_password)
+          Authors.changePassword(loggedIn, new_password)
           Redirect(routes.BlogsGuestController.index()).flashing("success" -> "main.success.password_changed")
         }
       })

app/controllers/BlogsController.scala

@@ -1,19 +1,21 @@
 package controllers
 
+import javax.inject.Inject
 import jp.t2v.lab.play2.auth.AuthElement
-import models.{BlogStatus, Editor}
-import play.api.Play.current
+import models.{Blogs, Authors, BlogStatus, Editor}
 import play.api.data.Form
 import play.api.data.Forms._
-import play.api.db.slick.DB
-import play.api.i18n.Messages
+import play.api.db.slick.DatabaseConfigProvider
+import play.api.i18n.{I18nSupport, MessagesApi, Messages}
 import play.api.mvc.Controller
-import services.{AuthorService, BlogService}
 import tools.PostAux
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
 
-object BlogsController extends Controller with DBElement with TokenValidateElement with AuthElement with AuthConfigImpl {
+case class BlogData(id:Option[String], name:String,alias:String,description:String,image:Option[String],logo:Option[String],url:Option[String], disqus:Option[String], googleAnalytics:Option[String], useAvatarAsLogo:Option[Boolean], status:Int)
+
+class BlogsController @Inject() (val messagesApi: MessagesApi, dbConfigProvider: DatabaseConfigProvider) extends Controller with TokenValidateElement with AuthElement with AuthConfigImpl with I18nSupport {
 
-  case class BlogData(id:Option[String], name:String,alias:String,description:String,image:Option[String],logo:Option[String],url:Option[String], disqus:Option[String], googleAnalytics:Option[String], useAvatarAsLogo:Option[Boolean], status:Int)
 
   val blogForm = Form(
     mapping(
@@ -30,64 +32,62 @@ object BlogsController extends Controller with DBElement with TokenValidateEleme
       "status" -> number(min=BlogStatus.INACTIVE.id, max=BlogStatus.PUBLISHED.id)
     )
     (BlogData.apply)(BlogData.unapply)
-    .verifying(Messages("blogs.error.duplicate_alias"), result => result match {
-      case blogData => checkAliasNotExists(blogData.id, blogData.alias)
-    }
-    )
   )
 
   def checkAliasName(alias:String) = alias.matches("[a-zA-Z0-9_-]+")   && alias.length() <= 32
 
-  /// this is ugly
-  def checkAliasNotExists(idOpt:Option[String], alias:String) = {
-    DB.withSession { implicit session =>
-      idOpt match {
-        case None =>
-          BlogService.findByAlias(alias).isEmpty
-        case Some(id) =>
-          BlogService.findById(id).map { blog =>
-            if (blog.alias == alias)
-              true
-            else
-              BlogService.findByAlias(alias).isEmpty
-          }.getOrElse(BlogService.findByAlias(alias).isEmpty)
-      }
+  def create = AsyncStack(AuthorityKey -> Editor, IgnoreTokenValidation -> None) { implicit request =>
+    Authors.findById(loggedIn.id).map {
+      case Some(author) =>
+        Ok(views.html.blogs_form(None, blogForm, loggedIn, PostAux.avatarUrl(author.email)))
+      case None =>
+        Redirect(routes.BlogsGuestController.index())
     }
   }
 
-  def create = StackAction(AuthorityKey -> Editor, IgnoreTokenValidation -> None) { implicit request =>
-    val ownerEmail = AuthorService.findById(loggedIn.id).map { _.email }.orNull
-    Ok(views.html.blogs_form(None, blogForm, loggedIn, PostAux.avatarUrl(ownerEmail)))
-  }
-
-  def edit(id:String) = StackAction(AuthorityKey -> Editor, IgnoreTokenValidation -> None) { implicit request =>
-    BlogService.findById(id).map { blog =>
-      val form = blogForm.fill(BlogData(Some(blog.id), blog.name, blog.alias, blog.description, blog.image, blog.logo, blog.url, blog.disqus, blog.googleAnalytics, blog.useAvatarAsLogo, blog.status.id))
-      val ownerEmail = AuthorService.findById(blog.owner).map { _.email }.orNull
-      Ok(views.html.blogs_form(Some(blog), form, loggedIn,  PostAux.avatarUrl(ownerEmail)))
-    }.getOrElse (Redirect(routes.BlogsGuestController.index()).flashing("error" -> Messages("blogs.error.not_found")))
+  def edit(id:String) = AsyncStack(AuthorityKey -> Editor, IgnoreTokenValidation -> None) { implicit request =>
+    Blogs.findById(id).flatMap {
+      case None =>
+        Future.successful(Redirect(routes.BlogsGuestController.index()).flashing("error" -> Messages("blogs.error.not_found")))
+      case Some(blog) =>
+        val form = blogForm.fill(BlogData(Some(blog.id), blog.name, blog.alias, blog.description, blog.image, blog.logo, blog.url, blog.disqus, blog.googleAnalytics, blog.useAvatarAsLogo, blog.status.id))
+        Authors.findById(blog.owner).map {
+          case None =>
+            Redirect(routes.BlogsGuestController.index()).flashing("error" -> Messages("blogs.error.not_found"))
+          case Some(owner) =>
+            Ok(views.html.blogs_form(Some(blog), form, loggedIn,  PostAux.avatarUrl(owner.email)))
+        }
+    }
   }
 
-  def save = StackAction(AuthorityKey -> Editor, IgnoreTokenValidation -> None) { implicit request =>
+  def save = AsyncStack(AuthorityKey -> Editor, IgnoreTokenValidation -> None) { implicit request =>
     blogForm.bindFromRequest.fold(
-      formWithErrors => BadRequest(views.html.blogs_form(None, formWithErrors, loggedIn, null)),
-      blogData => {
-        BlogService.create(loggedIn, blogData.name, blogData.alias, blogData.description, blogData.image, blogData.logo, blogData.url, blogData.disqus, blogData.googleAnalytics, blogData.useAvatarAsLogo)
-        Redirect(routes.BlogsGuestController.index()).flashing("success" -> Messages("blogs.success.created"))
-      }
+      formWithErrors => Future.successful(BadRequest(views.html.blogs_form(None, formWithErrors, loggedIn, null))),
+      blogData =>
+        Blogs.findByAlias(blogData.alias).flatMap {
+          case None =>
+            Blogs.create(loggedIn, blogData.name, blogData.alias, blogData.description, blogData.image, blogData.logo, blogData.url, blogData.disqus, blogData.googleAnalytics, blogData.useAvatarAsLogo).map { i =>
+              Redirect(routes.BlogsGuestController.index()).flashing("success" -> Messages("blogs.success.created"))
+            }
+          case Some(blog) =>
+            Future.successful(BadRequest(views.html.blogs_form(None, blogForm.fill(blogData).withGlobalError("blg"), loggedIn, null)))
+        }
     )
   }
 
-  def update(id:String) = StackAction(AuthorityKey -> Editor, IgnoreTokenValidation -> None) { implicit request =>
-    BlogService.findById(id).map { blog =>
-      blogForm.bindFromRequest.fold(
-        formWithErrors => BadRequest(views.html.blogs_form(Some(blog), formWithErrors, loggedIn, null)),
-        blogData => {
-          BlogService.update(blog, blogData.name, blogData.alias, blogData.description, blogData.image, blogData.logo, blogData.url, blogData.disqus, blogData.googleAnalytics, blogData.useAvatarAsLogo, BlogStatus(blogData.status))
-          Redirect(routes.BlogsGuestController.index()).flashing("success" -> Messages("blogs.success.updated"))
-        }
-      )
-    }.getOrElse (Redirect(routes.BlogsGuestController.index()).flashing("error" -> Messages("blogs.error.not_found")))
+  def update(id:String) = AsyncStack(AuthorityKey -> Editor, IgnoreTokenValidation -> None) { implicit request =>
+    Blogs.findById(id).map {
+      case Some(blog) =>
+        blogForm.bindFromRequest.fold(
+          formWithErrors => BadRequest(views.html.blogs_form(Some(blog), formWithErrors, loggedIn, null)),
+          blogData => {
+            Blogs.update(blog, blogData.name, blogData.alias, blogData.description, blogData.image, blogData.logo, blogData.url, blogData.disqus, blogData.googleAnalytics, blogData.useAvatarAsLogo, BlogStatus(blogData.status))
+            Redirect(routes.BlogsGuestController.index()).flashing("success" -> Messages("blogs.success.updated"))
+          }
+        )
+      case None =>
+        Redirect(routes.BlogsGuestController.index()).flashing("error" -> Messages("blogs.error.not_found"))
+    }
   }
 
 }

app/controllers/BlogsGuestController.scala

@@ -1,16 +1,20 @@
 package controllers
 
+import javax.inject.Inject
 import jp.t2v.lab.play2.auth.OptionalAuthElement
-import models.{Guest, Visitor}
+import models.{Blogs, Guest, Visitor}
+import play.api.db.slick.DatabaseConfigProvider
+import play.api.i18n.{I18nSupport, MessagesApi}
 import play.api.mvc.Controller
-import services.BlogService
-import scala.concurrent.Future
+import scala.concurrent.ExecutionContext.Implicits.global
 
-object BlogsGuestController extends Controller with DBElement with OptionalAuthElement with AuthConfigImpl {
+class BlogsGuestController @Inject() (val messagesApi: MessagesApi, dbConfigProvider: DatabaseConfigProvider) extends Controller  with OptionalAuthElement with AuthConfigImpl with I18nSupport {
 
   def index(pageNum:Int=0) = AsyncStack { implicit request =>
     val user : Visitor = loggedIn.getOrElse(Guest)
-    Future.successful(Ok(views.html.blogs_index("Blogs", BlogService.list(user, page = pageNum), user)))
+    Blogs.listForVisitor(user, page=pageNum).map { page =>
+      Ok(views.html.blogs_index("Blogs", page, user))
+    }
   }
 
 }