MapperUser.scala

package net.liftweb {
package mapper {

import net.liftweb.persistence.{MetaSimpleUser, SimpleUser}
import net.liftweb.mapper._
import net.liftweb.util.Helpers

trait MapperUser[T <: MapperUser[T]] extends SimpleUser[T] with LongKeyedMapper[T] with IdPK {
  self: T =>
  
  object fn extends MappedString(this, 64)
  def firstName = fn
  
  object ln extends MappedString(this, 64)
  def lastName = ln
  
  object emailAddr extends MappedEmail(this, 128)
  def email = emailAddr
  
  object pw extends MappedString(this, 64)
  def password = pw
  
  object pw_salt extends MappedString(this, 64) {
    override def defaultValue = Helpers.randomString(10)
  }
  def passwordSalt = pw_salt
}

trait MetaMapperUser[ModelType <: MapperUser[ModelType]] extends MetaSimpleUser[ModelType] with LongKeyedMetaMapper[ModelType] {
  self: ModelType =>
  
  def getByEmail(email: String) = find(By(emailAddr, email))
  
  def encryptPassword(password: String, salt: String) = Helpers.hash("{"+password+"} salt={"+salt+"}")
}

/*
// Example usage:
class ExampleUser extends MapperUser[ExampleUser] {
  def getSingleton = ExampleUser
}

object ExampleUser extends ExampleUser with MetaMapperUser[ExampleUser] {
}
*/

}
}

SimpleUser.scala

package net.liftweb {
package persistence {

import net.liftweb.common.{Box, Empty, Failure, Full}
import net.liftweb.http.{S, SessionVar}

trait SimpleUser[T <: SimpleUser[T]] {
  self: T =>

  def firstName: String
  def lastName: String
  def email: String
  def password: String
  def passwordSalt: String
  
  def name = firstName + " " + lastName

}

trait MetaSimpleUser[ModelType <: SimpleUser[ModelType]] {
  self: ModelType =>

  def getByEmail(email: String): Box[ModelType]
  
  def encryptPassword(password: String, salt: String): String
  
  protected object loggedInUser extends SessionVar[Box[ModelType]](Empty)
  def currentUser = loggedInUser.is
  
  def loggedIn_? = loggedInUser.is.isDefined
  def login(email: String, password: String): Box[ModelType] = {
    val u = for {
      userObj <- getByEmail(email) ?~ S.??("simpleuser.user.not.found")
      user <- Full(userObj) ?~ S.??("simpleuser.passwords.dont.match") if (userObj.password.toString == encryptPassword(password, userObj.passwordSalt.toString))
    } yield user
    loggedInUser(u)
    u
  }
  def loginUser(user: ModelType): Boolean = {
    loggedInUser.is match {
      case Full(u) if u == user => true
      case Empty => {
        loggedInUser(Full(user))
        true
      }
      case _ => false
    }
  }
  
  def loggedOut_? = !loggedIn_?
  def logout = loggedInUser(Empty).isEmpty
  def logoutUser(user: ModelType) = loggedInUser.is match {
    case Full(u) if u == user => logout
    case _ => false
  }
}

}
}