scala-news-reader

User.scala

(8477B)

 package com.joereader
 package model
 
 import org.bson.types._
 
 import net.liftweb._
 import util._
 import common._
 import http.{ StringField => _, BooleanField => _, _ }
 
 import net.liftweb.record._
 import net.liftweb.record.field._
 import net.liftweb.mongodb.record._
 import net.liftweb.mongodb.record.field._
 import net.liftmodules.mongoauth._
 import net.liftmodules.mongoauth.model._
 
 import com.joereader._
 import com.joereader.model.field._
 import config._
 import lib.rss._
 
 class User private () extends ProtoAuthUser[User] with ObjectIdPk[User] {
   def meta = User
 
   def userIdAsString: String = id.toString()
 
   object name extends StringField(this, 64)
 
   def firstName = name.get.split(" ").headOption getOrElse ""
 
   object about extends TextareaField(this, 500)
 
   object img extends StringField(this, 50)
 
   object bgImg extends StringField(this, 50)
 
   object otherVid extends MongoListField[User, String](this) with MongoListFieldExtra[User, String]
 
   object blogs extends ObjectIdRefListField(this, Blog) with ObjectIdRefListFieldExtra[User, Blog]
 
   def isWriter: Boolean = !blogs.get.isEmpty
 
   /* List of blog writer users this user follows. */
   object following extends BlogWriterUserListField(this)
 
   /*
    * Follow this user to view his shared articles
    * (only if this user is a writer)
    */
   object followers extends ObjectIdRefListField(this, User) with ObjectIdRefListFieldExtra[User, User]
 
   object saved extends ArticleListField(this)
 
   object shared extends ArticleSharedListField(this, this)
 }
 
 object User extends User with ProtoAuthUserMeta[User] with Loggable {
 
   import mongodb.BsonDSL._
 
   override def collectionName = "user.users"
 
   ensureIndex(email.name -> 1, unique = true)
   ensureIndex(username.name -> 1, unique = true)
   ensureIndex(name.name -> 1, unique = false)
 
   def defaultId = new ObjectId("0" * 24)
 
   def findByEmail(in: String): Box[User] = find(email.name, in)
 
   def findByName(in: String): Box[User] = find(name.name, in)
 
   def findByUsername(in: String): Box[User] =
     find(username.name, in.toLowerCase)
 
   def findByStringId(id: String): Box[User] =
     if (ObjectId.isValid(id) && id != "0" * 24)
       find(new ObjectId(id))
     else
       Empty
 
   override def onLogIn: List[User => Unit] =
     List(user => User.loginCredentials.remove())
 
   override def onLogOut: List[Box[User] => Unit] = List(
     x => logger.debug("User.onLogOut called."),
     boxedUser => boxedUser.foreach {
       u =>
         ExtSession.deleteExtCookie()
     })
 
   /*
    * MongoAuth vars
    */
   private lazy val siteName = MongoAuth.siteName.vend
   private lazy val sysUsername = MongoAuth.systemUsername.vend
   private lazy val indexUrl = MongoAuth.indexUrl.vend
   private lazy val registerUrl = MongoAuth.registerUrl.vend
   private lazy val loginTokenAfterUrl = MongoAuth.loginTokenAfterUrl.vend
 
   /*
    * LoginToken
    */
   override def handleLoginToken(): Box[LiftResponse] = {
     val resp = S.param("token").flatMap(LoginToken.findByStringId) match {
       case Full(at) if at.expires.isExpired => {
         at.delete_!
         RedirectWithState(indexUrl, RedirectState(() => {
           S.error("Login token has expired")
         }))
       }
       case Full(at) => find(at.userId.is).map(user => {
         if (user.validate.length == 0) {
           user.verified(true).save
           logUserIn(user)
           //at.delete_! (token is deleted at Password Reset)
           RedirectResponse(loginTokenAfterUrl)
         } else {
           at.delete_!
           regUser(user)
           RedirectWithState(registerUrl, RedirectState(() => {
             S.notice("Please complete the registration form")
           }))
         }
       }).openOr(RedirectWithState(indexUrl, RedirectState(() => {
         S.error("User not found")
       })))
       case _ => RedirectWithState(indexUrl, RedirectState(() => {
         S.warning("Login token not provided")
       }))
     }
 
     Full(resp)
   }
 
   // send an email to the user with a link for logging in
   def sendLoginToken(user: User) {
     import net.liftweb.util.Mailer._
 
     val token = LoginToken.createForUserId(user.id.get)
 
     val msgTxt =
       """
         |Someone requested a link to change your password on the %s website.
         |
         |If you did not request this, you can safely ignore it. It will expire 48 hours from the time this message was sent.
         |
         |Follow the link below or copy and paste it into your internet browser.
         |
         |%s
         |
         |Yours truly,
         |%s
       """.format(siteName, token.url, sysUsername).stripMargin
 
     sendMail(
       From(MongoAuth.systemFancyEmail),
       Subject("%s Password Help".format(siteName)),
       To(user.fancyEmail),
       PlainMailBodyType(msgTxt))
   }
 
   def handleInviteToken(): Box[LiftResponse] = {
     var resp: LiftResponse = DoRedirectResponse("/")
 
     S.param("token").flatMap(InviteToken.findByStringId) match {
       case Full(at) if at.expires.isExpired =>
         at.delete_!
         resp = RedirectWithState(indexUrl, RedirectState(() => {
           S.error("Invite token has expired.")
         }))
 
       case Full(at) =>
 
         // Find user if he is registered already else create user
         val userBoxed = findByEmail(at.email.is)
         val user: User = userBoxed openOr {
           createRecord.
             email(at.email.get).
             name(at.name.get).
             password(StringHelpers.randomString(20), true).
             username(StringHelpers.randomString(15))
         }
 
         Blog.findByStringId(at.blogId.get.toString).map {
           blog =>
             val blogWriter =
               BlogWriter.createRecord.user(user.id.get).name(at.name.get)
 
             blog.writers.addSafely(blogWriter).save
             user.blogs.add(blog).verified(true).save
 
             if (userBoxed.isDefined)
               resp = RedirectWithState(Site.categoriesLoc.calcHref(blog),
                 RedirectState(() => {
                   S.notice("Congratulations! You are verified with " +
                     blog.name.get + "!")
                 }))
             else
               resp = RedirectWithState(Site.signUp3.url,
                 RedirectState(() => {
                   snippet.BlogIdVar(at.blogId.get.toString)
                   snippet.VerifiedVar(true)
                   S.notice("Congratulations! You are verified with " +
                     blog.name.get + "!")
                 }))
         }
 
         // Remove token
         at.delete_!
 
         // Log user in
         if (isLoggedIn) logUserOut()
         logUserIn(user, isAuthed = true)
 
       case _ =>
         resp = RedirectWithState(indexUrl, RedirectState(() => {
           S.warning("Invite token is missing.")
         }))
     }
 
     Full(resp)
   }
 
   def sendInviteToken(name: String, email: String, user: User, blog: Blog) {
     import net.liftweb.util.Mailer._
 
     val token = InviteToken.create(email, name, blog.id.is)
     val msgTxt =
       """
         |Hi %s,
         |
         |%s has invited you to Read Means to become a member of your
         |current blog, %s.
         |
         |Click below to join:
         |%s
         |
         |Yours truly,
         |%s
       """.
         format(name, user.name.get, blog.name.get, token.url,
           MongoAuth.systemUsername.vend).stripMargin
 
     sendMail(
       From(MongoAuth.systemFancyEmail),
       Subject("%s invites you to %s".
         format(user.name.get, MongoAuth.siteName.vend)),
       To(email),
       PlainMailBodyType(msgTxt))
   }
 
   // used during login process (holds email address)
   object loginCredentials extends SessionVar[String]("")
 
   object regUser
     extends SessionVar[User](createRecord.email(loginCredentials.is))
 
 }
 
 object SystemUser {
   private val username = "julio"
   private val email = "j.cabrra@gmail.com"
 
   lazy val user: User = User.find("username", username) openOr {
     User.createRecord
       .name("Julio")
       .username(username)
       .email(email)
       .verified(true)
       .password("deanjoe321", isPlain = true)
       .save
   }
 }
 
 object TestUser {
   private val username = "testuser"
   private val email = "test@example.com"
 
   lazy val user: User = User.find("username", username) openOr {
     User.createRecord
       .name("Test Man")
       .username(username)
       .email(email)
       .verified(true)
       .password("test1234", isPlain = true)
       .save
   }
 
   def isLoggedIn = User.currentUser.
     exists(_.username.get == TestUser.user.username.get)
 }