pyc-website

UserSnip.scala

(10759B)

 package inc.pyc
 package snippet
 
 import lib._
 import rest._
 import model._
 import field._
 import xml._
 import net.liftweb._
 import common._
 import http._
 import util._
 import Helpers._
 import json._
 import JsonDSL._
 import JsonAST.{JValue, JString, JBool}
 import net.liftmodules.mongoauth.model.ExtSession
 import net.liftmodules.extras.SnippetHelper
 import inc.pyc.rest.IdVerificationFiles
 
 /**
  * Basic User information from a snippet.
  */
 sealed trait UserSnippet extends SnippetHelper with Logger {
 
   protected def user: Box[User]
 
   protected def serve(snip: User => NodeSeq): NodeSeq =
     (for {
       u <- user ?~ "User not found"
     } yield {
       snip(u)
     }): NodeSeq
     
   protected def serve(snip: User => CssSel): CssSel =
     (for {
       u <- user ?~ "User not found"
     } yield {
       snip(u)
     }): CssSel
 
   def username(in: NodeSeq): NodeSeq = serve { user =>
     Text(user.username.get)
   }
 
   def name(in: NodeSeq): NodeSeq = serve { user =>
     val name = user.fname.get + " " + user.lname.get
     if (name.length > 1) Text(name)
     else Text(user.username.get)
   }
   
   def limit(in: NodeSeq): NodeSeq = serve {
     user => Text(user.purchaseLimit.get.toString)
   }
   
   def identifier(in: NodeSeq): NodeSeq = serve {
     user =>
       if(user.fname.get.isEmpty) Text(user.email.get)
       else name(in)
   }
 }
 
 /**
  * Basic logged in user information from a snippet.
  */
 trait CurrentUser extends UserSnippet {
   protected def user = User.currentUser
 }
 
 object CurrentUser extends CurrentUser
 
 /**
  * Angular snippet for accessing user information.
  */
 trait AngularUserSnippet extends AngularSnippet {
   
   protected def user: Box[User]
   
   protected def serve(snip: User => JValue): JValue =
     (for {
       u <- user ?~ "User not found"
     } yield {
       snip(u)
     }): JValue
     
   /** Validates and saves the currently signed in user. */
   protected def validateAndSave(f: () => Unit): JValue = validateUser {
     user =>
       f()
       user.save()
       NgAlert.success
   }
   
   /** Validates and updates the currently signed in user. */
   protected def validateAndUpdate(f: () => Unit): JValue = validateUser {
     user =>
       f()
       user.update
       NgAlert.success
   }
   
   protected def validateUser(f: User => JValue): JValue = serve {
     user =>
       user.validate match {
         case Nil => f(user)        
         case errors =>
           NgAlert.danger(S ? "Invalid_submission", errors)
       }
   }
 }
 
 /**
  * Angular snippet for accessing logged in user information.
  */
 trait AngularCurrentUser extends AngularUserSnippet {
   protected def user = User.currentUser
 }
 
 class UserLogin extends AngularSnippet {
   
   def roundTrips: List[RoundTripInfo] = List("submit" -> submit _)
     
   def submit(model: JValue): JValue = {
     for {
       JString(e) <- model \ "email"
       JString(password) <- model \ "password"
       JBool(remember) <- model \ "remember"
     } yield {
       val email = e.toLowerCase.trim
       User.loginCredentials(LoginCredentials(email, remember))
       
       User.findByEmail(email) match {
           case Full(user) if !user.verified.get =>
             NgAlert.danger(
               <span>{S ? "unverified.title"}:</span> ++
               <p>{S ? "unverified.message"}.</p>, Nil)
               
           case Full(user) if (user.password.isMatch(password)) =>
             User.logUserIn(user, remember)
             if (remember) User.createExtSession(user.id.get)
             else ExtSession.deleteExtCookie()
             NgAlert.success
           
           case _ =>
             NgAlert.danger(
               <span>{S ? "invalid.title"}:</span> ++
               <p>{S ? "invalid.message"}.</p>, Nil)
         }
     }
   }
 }
 
 class PasswordChange extends AngularCurrentUser {
   
   /** 
    *  Passwords must match this pattern.
    *  - makes sure there are no white-space characters
    *  - minimum length of 8
    *  - at least one non-alpha character
    */
   def passwordPattern: String = "^(?=.*[^a-zA-Z])\\S{8,}$"
   
   def roundTrips: List[RoundTripInfo] = List("submit" -> submit _)
       
   def submit(model: JValue): JValue = serve {
     user =>  
       for {
         JString(password) <- model \ "password"
       } yield {
         
         if(password matches passwordPattern) {
           
           user.password(password)
           user.password.hashIt
           user.save()
           
           NgAlert.success(
         	    <span>{S ? "password_updated"}</span>)
         } else {
           NgAlert.danger(
         	    <span>{S ? "password_req"}:</span> ++
         	    <ul><li>{S ? "password_whitespace"}</li><li>{S ? "password_atleast8"}</li><li>{S ? "password_nonalpha"}</li></ul>, Nil)
         }
         
       }
     }
 }
 
 class PasswordRecovery extends AngularSnippet {
   
   def roundTrips: List[RoundTripInfo] = List("submit" -> submit _)
       
   def submit(model: JValue): JValue = {
     for {
       JString(e) <- model \ "email"
     } yield {
       val email = e.toLowerCase.trim
       
       def msg = NgAlert.success(
             <span>{S ? "sent.title"}</span> ++
             <p>{S ? "sent.message"}.</p>)
       
       User.findByEmail(email) match {
         case Full(user) =>
           User.sendLoginToken(user)
           User.loginCredentials.remove()
           msg
           
         case _ => msg
       }
     }
   }
 }
 
 class UserRegistration extends AngularSnippet {
   
   def roundTrips: List[RoundTripInfo] = List("submit" -> submit _)
   
   def submit(model: JValue): JValue = {
     for {
       JString(e) <- model \ "email"
     } yield {
       val email = e.toLowerCase.trim
       val user = User.createRecord
       user.email(email)
       user.username(Helpers.randomString(20))
       user.password(Helpers.randomString(20))
       user.password.hashIt
       
       user.validate match {
         case Nil =>
           user.save()
           User.sendRegistrationToken(user)
         
           NgAlert.success(
         	<span>{S ? "thanks.title"}.</span> ++
         	<p>{S ? "thanks.message"}.</p>
           )
         case errors =>
           NgAlert.danger(
         	Text(S ? "Invalid_submission"), 
         	errors
           )
       }
     }
   }
 }
 
 class UserSettings extends AngularSnippet {
   import com.foursquare._
   import rogue.LiftRogue._
     
   def roundTrips: List[RoundTripInfo] = List(
       "submit" -> submit _)
     
   def submit(model: JValue): JValue = 
     for {
       JString(id) <- model \ "id"
       JString(fname) <- model \ "fname"
       JString(lname) <- model \ "lname"
       JString(dob) <- model \ "dob"
       JString(license) <- model \ "driversLicense"
     } yield {
       
       val exists = User.
     	where(_.fname eqs fname).
     	and(_.lname eqs lname).
     	and(_.dob eqs dob).
     	and(_.driversLicense eqs license).
     	exists()
     	
       if(exists) {
         NgAlert.danger(S ? "verify_already_exists", Nil)
       } else {
         User.findByStringId(id).map {
           user =>
             user.
               fname(fname).
               lname(lname).
               dob(dob).
               driversLicense(license).
               save()
 
             NgAlert.success("updated")
 
         } openOr JNull
       }
     }
 }
 
 class UserSettingsEmail extends AngularCurrentUser {
   
   def roundTrips: List[RoundTripInfo] = List(
       "submit" -> submit _, 
       "init" -> init _)
   
   def submit(model: JValue): JValue = serve {
     user =>
       for {
         JString(e) <- model \ "email"
       } yield {
         val email = e.toLowerCase.trim
         EmailResetToken.sendToken(user, email)
         
         NgAlert.success(
         	Text(S ? "verify_email_msg")
         )
       }
   }
   
   def init(model: JValue): JValue = serve {
     user =>
       ("email" -> user.email.get)
   }
 }
 
 
 class UserVerifyPassword extends AngularCurrentUser with UserSnippet {
     
   def roundTrips: List[RoundTripInfo] = List(
       "init" -> init _)
       
   def init(ignore: JValue): JValue = serve {
     user: User =>
       user.verifypass.reset.update // set a new password
       
       ("password" -> user.verifypass.get) ~
       ("limit" -> user.userLimitAsString): JValue
   }
   
   def show(in: NodeSeq): NodeSeq = serve {
     user =>
       if(user.limit1k) NodeSeq.Empty else in
   }
 }
 
 
 class VerificationSteps extends CurrentUser {
   def render = serve {
     user: User =>
       "wizard [current-step]" #> s"'${user.userLimitAsString}'"
   } 
 }
 
 
 class PhoneVerification extends AngularCurrentUser with Logger {
   
   lazy val smscode = (100000 + new scala.util.Random().nextInt(900000)).toString
   var phone = ""
   
   def roundTrips: List[RoundTripInfo] = List(
       "sendsms" -> sendsms _,
       "verifyphone" -> verifyphone _,
       "init" -> init _)
       
   
   def sendsms(model: JValue): JValue = serve {
     user =>
       for {
         JString(newPhone) <- model \ "phone"
       } yield {
         val msg = S ? "sms_code_msg" format (user.fname.get, smscode)
         
         if (phone == newPhone) {
           NgAlert.success
         } else if (Twilio.sms(newPhone, msg)) {
           phone = newPhone
           NgAlert.success
         } else {
           NgAlert.danger(
         	  Text(S ? "technical_difficulties"), Nil)
         }
         
       }
   }
   
   def verifyphone(model: JValue): JValue = serve {
     user =>
       for {
         JString(smscode) <- model \ "smscode"
       } yield 
         
         if(this.smscode == smscode) {
           user.
             purchaseLimit(USAPurchaseLimit.D3k).
             phone(phone)
           validateAndUpdate(() => {})
           
           NgAlert.success(("purchaseLimit" -> user.purchaseLimit.get.toString))
         } else {
           NgAlert.danger(
             Text(S ? "sms_verify_fail"), Nil)
         }
       
   }
   
   def init(model: JValue): JValue = serve {
     user =>
       ("phone" -> user.phone.get)
   }
 }
 
 
 class IdVerification extends AngularCurrentUser {
   
   def roundTrips: List[RoundTripInfo] = List(
       "submit" -> submit _)
       
   def submit(model: JValue): JValue = serve {
     user =>
       
       import IdVerificationHelper._
       val service = s3(createS3Folder(user))
       val success = upload(service)
 
       if (success) {
         user.purchaseLimit(USAPurchaseLimit.D10k_?)
         user.update
         notifyIdentityRequest(user)
         NgAlert.success(
           <span>{S ? "file_received"}:</span> ++
           <p>{S ? "file_review"}.</p>, 
           ("purchaseLimit" -> user.userLimitAsString))
       } else {
         NgAlert.danger(Text(S ? "file_upload_fail"), Nil)
       }
   }
 }
 
 
 class PurchaseLimit extends AngularCurrentUser {
   
   def roundTrips: List[RoundTripInfo] = List("init" -> init _)
       
   def init(model: JValue): JValue = serve {
     user =>  
       ("purchaseLimit" -> user.userLimitAsString)
     }
 }