pyc-website

User.scala

(7446B)

 package inc.pyc
 package model
 
 import lib._
 import config._
 import field._
 import lib.RogueMetaRecord
 import org.bson.types.ObjectId
 import org.joda.time.DateTime
 import net.liftweb._
 import common._
 import http.{StringField => _, BooleanField => _, _}
 import mongodb.record.field._
 import record.field._
 import net.liftmodules.mongoauth._
 import net.liftmodules.mongoauth.field._
 import net.liftmodules.mongoauth.model._
 import java.util.regex.Pattern
 import scala.concurrent._
 import ExecutionContext.Implicits.global
 
 class User private () extends ProtoAuthUser[User] with ObjectIdPk[User] with USAUserVerification[User] {
   def meta = User
   
   def userIdAsString: String = id.toString
 
   /**
    * User's first name.
    */
   object fname extends StringField(this, 32) {
     override def validations =
       valMaxLen(32, "First Name must be 32 characters or less") _ ::
       super.validations
   }
   
   /**
    * User's last name.
    */
   object lname extends StringField(this, 32) {
     override def validations =
       valMaxLen(32, "Last Name must be 32 characters or less") _ ::
       super.validations
   }
   
   /**
    * User's phone number.
    */
   object phone extends OptionalStringField(this, 10) {
     override def validations =
       valRegex(Pattern.compile("[0-9]{10}"), "Phone number must be 10 digits long") _ ::
       super.validations
   }
   
   /**
    * User's driver's license.
    */
   object driversLicense extends OptionalStringField(this, 50)
   
   /**
    * User's date of birth.
    */
   object dob extends OptionalStringField(this, 6) {
     override def validations =
       valRegex(Pattern.compile("[0-9]{6}"), "Date of Birth should be 6 digits long (xx/xx/xx)") _ ::
       super.validations
   }
   
   /**
    * User's one-time password.
    */
   object verifypass extends StringField(this, 15) {
     
     def reset = {
       set(StringUtils.randomString(7))
       owner
     }
     
     override def defaultValue = StringUtils.randomString(7)
   }
 
   /**
    * When user's account was created.
    */
   def whenCreated: DateTime = new DateTime(id.get.getTime)
   
   /**
    * Country the user is located (primarily)
    */
   object country extends CountryField(this) {
     override def defaultValue = Countries.USA
   }
   
   /**
    * Bitcoin addresses the user has used to buy bitcoin.
    */
   object addresses extends MongoListField[User, String](this) with MongoListFieldExtra[User, String]
 }
 
 object User extends User with ProtoAuthUserMeta[User] with RogueMetaRecord[User] with Loggable {
   import mongodb.BsonDSL._
 
   override def collectionName = "user.users"
 
   ensureIndex((email.name -> 1), ("unique" -> true))
   ensureIndex((phone.name -> 1), ("unique" -> true) ~ ("sparse" -> true))
   
   // look at https://jira.mongodb.org/browse/SERVER-3934
   ensureIndex((addresses.name -> 1), ("unique" -> true) ~ ("sparse" -> true) ~ ("v" -> 0))
 
   def findByEmail(in: String): Box[User] = find(email.name, in)
   
   def findByAddress(in: String): Box[User] = find(addresses.name, in)
   
   def findByPhone(in: String): Box[User] = find(phone.name, in)
 
   def findByStringId(id: String): Box[User] =
     if (ObjectId.isValid(id)) 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.get).map(user => {
         if (user.validate.length == 0) {
           user.verified(true)
           user.save()
           logUserIn(user)
           at.delete_!
           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)
   }
 
   /**
    * Sends an email to the user with a link for logging in.
    */
   def sendLoginToken(user: User): Future[Unit] = Future {
     import net.liftweb.util.Mailer._
     
       val token = LoginToken.createRecord.userId(user.id.get).save()
       val url = "%s%s?token=%s".format(Site.host, MongoAuth.loginTokenUrl.vend, token.id.toString)
       val title = "Account Login"
       val btn = "Complete "+title
       val msg = "Hello, someone requested a link to log in to your account."
 
       HtmlEmail.createToken(false, "", msg, btn, url, false) map {
         sendMail(
           From(MongoAuth.systemFancyEmail),
           Subject("%s: %s".format(siteName, title)),
           To(user.fancyEmail),
           _
         )
       }
   }
   
   /**
    * Sends registration token.
    */
   def sendRegistrationToken(user: User): Future[Unit] = Future {
     import net.liftweb.util.Mailer._
 
       val token = LoginToken.createRecord.userId(user.id.get).save()
       val url = "%s%s?token=%s".format(Site.host, MongoAuth.loginTokenUrl.vend, token.id.toString)
       val title = "Account Registration"
       val btn = "Complete "+title
       val msg = "Thank you for using bitcoin. Please follow the link to complete your registration."
 
       HtmlEmail.createToken(false, "", msg, btn, url, false) map {
         sendMail(
           From(MongoAuth.systemFancyEmail),
           Subject("%s: %s".format(siteName, title)),
           To(user.fancyEmail),
           _
         )
       }
   }
 
   /*
    * ExtSession
    */
   def createExtSession(uid: ObjectId) = ExtSession.createExtSessionBox(uid)
 
   /*
   * Test for active ExtSession.
   */
   def testForExtSession: Box[Req] => Unit = {
     ignoredReq => {
       if (currentUserId.isEmpty) {
         ExtSession.handleExtSession match {
           case Full(es) => find(es.userId.get).foreach { user => logUserIn(user, false) }
           case Failure(msg, _, _) =>
             logger.warn("Error logging user in with ExtSession: %s".format(msg))
           case Empty =>
         }
       }
     }
   }
 
   // used during login process
   object loginCredentials extends SessionVar[LoginCredentials](LoginCredentials(""))
   object regUser extends SessionVar[User](createRecord.email(loginCredentials.is.email))
 }
 
 case class LoginCredentials(email: String, isRememberMe: Boolean = false)
 
 object SystemUser {
   private val username = "pyc"
   private val email = "noreply@pycbitcoin.com"
 
   lazy val user: User = User.find("username", username) openOr {
     User.createRecord
       .fname("PYC")
       .username(username)
       .email(email)
       .verified(true)
       .password("abc123", true)
       .save()
   }
 }