8 The Mapper and Record Frameworks

<project ...>
  ...
  <dependencies>
    ...
    <dependency>
      <groupId>net.liftweb</groupId>
      <artifactId>lift-mapper</artifactId>
      <version>1.0</version> <!-- or 1.1-SNAPSHOT, etc -->
    </dependency>
  </dependencies>
  ...
</project>

import _root_.net.liftweb.mapper._

.. standard Lift imports ...
import _root_.net.liftweb.mapper._
import _root_.java.sql._
​
object DBVendor extends ConnectionManager {
  // Force load the driver
  Class.forName("org.postgresql.Driver")
  // define methods
  def newConnection(name : ConnectionIdentifier) = {
    try {
      Full(DriverManager.getConnection(
           "jdbc:postgresql://localhost/mydatabase",
           "root", "secret"))
    } catch {
      case e : Exception => e.printStackTrace; Empty
    }
  }
  def releaseConnection (conn : Connection) { conn.close }
}
​
class Boot {
  def boot {
    ...
    DB.defineConnectionManager(DefaultConnectionIdentifier, DBVendor)
  }
}

import _root_.java.math.MathContext
​
class Expense extends LongKeyedMapper[Expense] with IdPK {
  def getSingleton = Expense
  object dateOf extends MappedDateTime(this)
  object description extends MappedString(this,100)
  object amount extends MappedDecimal(this, MathContext.DECIMAL64, 2)
  object account extends MappedLongForeignKey(this, Account)
}

import _root_.java.math.MathContext
import _root_.net.liftweb.record._
​
class Expense extends KeyedRecord[Expense,Long] {
  def meta = Expense
  def primaryKey = id
  object id extends LongField(this) with KeyField[Long,Expense]
  object dateOf extends DateTimeField(this)
  object description extends StringField(this, 100)
  object amount extends DecimalField(this, MathContext.DECIMAL64, 2)
  object account extends LongField(this)
}

object Expense extends Expense with LongKeyedMetaMapper[Expense] {
  override def fieldOrder = List(dateOf, description, amount)
}

myEntry.dateOf(new Date).description("A sample entry")
myEntry.amount(BigDecimal("127.20"))

// mapper
val tenthOfAmount = myEntry.amount.is / 10
val formatted = String.format("%s : %s",
                              myEntry.description.is,
                              myEntry.amount.is.toString)
// record
if (myEntry.description.value == "Doughnuts") {
  println("Diet ruined!")
}

class Expense extends LongKeyedMapper[Expense] with IdPK {
 ...
  object account extends MappedLongForeignKey(this, Account)
  def accountName = 
    Text("My account is " + (account.obj.map(_.name.is) openOr "Unknown"))
}
​
class Account ... {
  ...
  def entries = Expense.findAll(By(Expense.account, this.id))
}

class Tag extends LongKeyedMapper[Tag] with IdPK {
  def getSingleton = Tag
  object name extends MappedString(this,100)
}
object Tag extends Tag with LongKeyedMetaMapper[Tag] {
  override def fieldOrder = List(name)
}

class ExpenseTag extends LongKeyedMapper[ExpenseTag] with IdPK {
  def getSingleton = ExpenseTag
  object tag extends MappedLongForeignKey(this,Tag)
  object expense extends MappedLongForeignKey(this,Expense)
}
​
object ExpenseTag extends ExpenseTag with LongKeyedMetaMapper[ExpenseTag] {
  def join (tag : Tag, tx : Expense) = 
    this.create.tag(tag).expense(tx).save
}

class Expense ... {
  object tags extends HasManyThrough(this, Tag, 
    ExpenseTag, ExpenseTag.tag, ExpenseTag.expense)
}

class Expense ... {
  object account extends ... {
    override def dbIndexed_? = true
  }
}

object Expense extends ... {
  // equivalent to the previous listing
  override dbIndexes = Index(IndexField(account)) :: Nil
  // equivalent to "create index ... on transaction_t (account, description(10))"
  override dbIndexes = Index(IndexField(account), 
                             BoundedIndexField(description,10))
}

Schemifier.schemify(true, Log.infoF _, User, Expense, Account, Tag, ExpenseTag)

class ExpenseTag ... {
  object expense extends ... {
    override def dbColumnName = "expense_id"
  }
}

if (! myExpense.delete_!) S.error("Couldn’t delete the expense!")
//or
if (! (Expense delete_! myExpense)) S.error(...)

val myEntries = Expense.findAll(By(Expense.account, myAccount.id))

// select all root nodes from the forest
TreeNode.findAll(ByRef(TreeNode.parent,TreeNode.id))

val cExpenses = 
  ExpenseTag.findAll(
    In(ExpenseTag.tag,
       Tag.id,
       Like(Tag.name, "c%"))).map(_.expense.obj.open_!).removeDuplicates

class Expense ... {
  ...
  override def equals (other : Any) = other match {
    case e : Expense if e.id.is == this.id.is => true
    case _ => false
  }
​
  override def hashCode = this.id.is.hashCode
  ...
}

def recentTags = {
  val joins = ExpenseTag.findAll(
    InRaw(ExpenseTag.expense,
          "select id from Expense where dateOf > (CURRENT_DATE - interval ’30 days’)",
          IHaveValidatedThisSQL("dchenbecker", "2008-12-03"))
  joins.map(_.expense.obj.open_!).removeDuplicates
}

val recentEntries = Expense.findAll(
  BySql("dateOf > (CURRENT_DATE - interval ’30 days’)",
        IHaveValidatedThisSQL("dchenbecker","2008-12-03"))

val amountRange = Expense.findAll(
  BySql("amount between ? and ?", lowVal, highVal))

def deleteBefore (date : Date) = 
  Expense.bulkDelete_!!(By_<(Expense.dateOf, date))

val cheapestFirst = 
  Expense.findAll(OrderBy(Expense.amount,Ascending))
// or
val cheapestFirst = 
  Expense.findAll(OrderBySql("amount asc"),
    IHaveValidatedThisSQL("dchenbecker", "2008-12-03"))

val offset = S.param("offset").map(_.toLong) openOr 0
Expense.findAll(StartAt(offset), MaxRows(20))

Expense.findAll(Like(Expense.description, "Gift for%"),
                OrderBy(Expense.dateOf,Descending),
                StartAt(offset),
                MaxRows(pageSize))

def loadExpensePlusAccount (id : Long) =
  Expense.findAll(By(Expense.id, id),
                    PreCache(Expense.account))

def tags = 
  ExpenseTag.findAll(By(ExpenseTag.expense, this.id)).map(_.tag.obj.open_!)

import _root_.java.text.DateFormat
...
object dateOf extends MappedDateTime(this) {
  final val dateFormat = 
    DateFormat.getDateInstance(DateFormat.SHORT)
  override def asHtml = Text(dateFormat.format(is))
}

myEntry.toForm(Full("Save"), { _.save })

myEntry.toForm (Full("Login"), "/member/profile")

<!-- Example description field row for Record’s toForm method -->
<tr>
  <th><lift:field_label name="description" /></th>
  <td><lift:field name="description" /> 
      <lift:field_msg name="description" /></td>
</tr>

S.warning(myEntry.amount.uniqueFieldId, 
          "You have entered a negative amount!")
S.warning("amount_id", "This is brittle")

import _root_.java.util.Date
​
class Expense extends LongKeyedMapper[Expense] with IdPK {
  ...
  object dateOf extends MappedDateTime(this) {
    def noFutureDates (time : Date) = {
      if (time.getTime > System.currentTimeMillis) {
        List(FieldError(this, "You cannot make future expense entries"))
      } else {
        List[FieldError]()
      }
    }
  }
  ...
}

import _root_.java.util.Date
import _root_.net.liftweb.http.FieldIdentifier
​
object ValidationMethods {
  def noFutureDates (field : FieldIdentifier)(time : Date) = {
    if (time.getTime > System.currentTimeMillis) {
      List(FieldError(field, "You cannot make future expense entries"))
    } else {
      List[FieldError]()
    }
  }
  ...
}

  def noFutureDates (time : Date) = { ... }
  override def validations = noFutureDates _ :: Nil
}
​
// Using the alternate definition:
object dateOf extends MappedDateTime(this) {
  override def validations = ValidationMethods.noFutureDates(dateOf) _ :: Nil
}

object Expense extends Expense LongKeyedMetaMapper[Expense] 
    with CRUDify[Long,Expense] {
  ... normal def here ...
  // disable delete functionality
  override def deleteMenuLoc = Empty
}

class Boot {
  def boot {
    ...
    val menus = ... Menu(Loc(...)) :: Expense.menus
    LiftRules.setSiteMap(SiteMap(menus : _*))
  }
}

object Expense extends LongKeyedMapper[Expense] with LifecycleCallbacks {
  ...
  override def afterSave { myCometActor ! this }
}

import _root_.java.math.{MathContext, RoundingMode}
​
class MappedDecimal[T <: Mapper[T]] (val fieldOwner : T,
                                     val context : MathContext,
                                     val scale : Int) extends MappedField[BigDecimal,T] {
  // ... constructor taking initial value ...
  def this(fieldOwner : T, value : BigDecimal, context: MathContext) = {
    this(fieldOwner, context, value.scale)
    setAll(value) // we’ll cover this later in this section
  }
​
  def this(fieldOwner : T, value : BigDecimal) = {
    this(fieldOwner, MathContext.UNLIMITED, value.scale)
    setAll(value)
  }

  private val zero = BigDecimal("0") 
  def defaultValue = zero.setScale(scale)
  def dbFieldClass = classOf[BigDecimal]
​
  // The data and orgData variables are used so that
  // we know when the field has been modified by the user
  private var data : BigDecimal = defaultValue
  private var orgData : BigDecimal = defaultValue
  private def st (in : BigDecimal) {
    data = in
    orgData = in
  }
  
  // The i_is_! and i_was_! methods are used internally to
  // keep track of when the field value is changed. In our 
  // instance they delegate directly to the data and orgData 
  // variables
  protected def i_is_! = data
  protected def i_was_! = orgData
  override def doneWithSave() {
    orgData = data
  }

  override def readPermission_? = true
  override def writePermission_? = true
  protected def i_obscure_!(in : BigDecimal) = defaultValue
  protected def real_i_set_!(value : BigDecimal): BigDecimal = {
    if (value != data) {
      data = value
      dirty_?(true)
    }
    data
  }

  def setFromAny (in : Any) : BigDecimal =
    in match {
      case bd : BigDecimal => setAll(bd)
      case n :: _ => setFromString(n.toString)
      case Some(n) => setFromString(n.toString)
      case Full(n) => setFromString(n.toString)
      case None | Empty | Failure(_, _, _) | null => setFromString("0")
      case n => setFromString(n.toString)
    }
​
  def setFromString (in : String) : BigDecimal = {
    this.setAll(BigDecimal(in))
  }
​
  protected def setAll (in : BigDecimal) = set(coerce(in))
​
  // Make a separate method for properly adjusting scale and rounding.
  // We’ll use this method later in the class as well.
  protected coerce (in : BigDecimal) = 
    new BigDecimal(in.bigDecimal.setScale(scale, context.getRoundingMode))

def targetSQLType = Types.DECIMAL
def jdbcFriendly(field : String) = i_is_!.bigDecimal
def real_convertToJDBCFriendly(value: BigDecimal): Object = value.bigDecimal
​
// The following methods are used internally by Lift to
// process values retrieved from the database. 
​
// We don’t convert from Boolean values to a BigDecimal, so this returns null
def buildSetBooleanValue(accessor : Method, columnName : String) : 
  (T, Boolean, Boolean) => Unit = null
​
// Convert from a Date to a BigDecimal. Our assumption here is that we can take
// The milliseconds value of the Date.
def buildSetDateValue(accessor : Method, columnName : String) : 
    (T, Date) => Unit =
  (inst, v) => 
    doField(inst, accessor,{
      case f: MappedDecimal[T] => 
        f.st(if (v == null) defaultValue else coerce(BigDecimal(v.getTime)))
    })
​
// Convert from a String to a BigDecimal. Since the BigDecimal object can
// directly convert a String, we just pass the String directly.
def buildSetStringValue(accessor: Method, columnName: String) : 
    (T, String) => Unit =
  (inst, v) => 
    doField(inst, accessor,{
      case f: MappedDecimal[T] => 
        f.st(coerce(BigDecimal(v)))
    })
​
// Convert from a Long to a BigDecimal. This is slightly more complex than 
// for a String, since we need to check for null values.
def buildSetLongValue(accessor: Method, columnName : String) : 
    (T, Long, Boolean) => Unit = 
  (inst, v, isNull) => 
    doField(inst, accessor, {
      case f: MappedDecimal[T] => 
        f.st(if (isNull) defaultValue else coerce(BigDecimal(v)))
    })
​
// Convert from an AnyRef (Object). We simply use the String value 
// of the input here.
def buildSetActualValue(accessor: Method, data: AnyRef, columnName: String) : 
    (T, AnyRef) => Unit =
  (inst, v) => 
    doField(inst, accessor, {
      case f: MappedDecimal[T] => f.st(coerce(BigDecimal(v.toString)))
    })
​
def fieldCreatorString(dbType: DriverType, colName: String): String = {
  val suffix = if (context.getPrecision == 0) "" else {
    "(" + context.getPrecision + "," + scale + ")"
  }
  colName + " DECIMAL" + suffix
}

class User extends ProtoUser[User] {
  override def shortName = firstName.is
  override lastNameDisplayName = "surname"
}

// in Boot.scala
LiftRules.setSiteMap(SiteMap((... :: User.sitemap) :_*))

object SalesDB extends ConnectionIdentifier {
  def jndiName = "sales"
}
​
object EmployeeDB extends ConnectionIdentifier {
  def jndiName = "employees"
}

object DBVendor extends ConnectionManager {
  Class.forName("org.postgresql.Driver")
 
  def newConnection(name : ConnectionIdentifier) = {
    try {
      name match {
        case SalesDB =>
          Full(DriverManager.getConnection(
            "jdbc:postgresql://localhost/sales",
            "root", "secret"))
        case EmployeeDB =>
          Full(DriverManager.getConnection(
            "jdbc:postgresql://server/employees",
            "root", "hidden"))
    } catch {
      case e : Exception => e.printStackTrace; Empty
    }
  }
  def releaseConnection (conn : Connection) { conn.close }
}

object EmployeeMeta extends Employee with LongKeyedMetaMapper[Employee] {
  ...
  override def dbDefaultConnectionIdentifier = EmployeeDB
  ...
}

val employees = EmployeeMeta.findAllDb(EmployeeDB)

class Expense extends LongKeyedMapper[Expense] {
  ... fields, etc ...
​
  override def dbCalculateConnectionIdentifier = {
    case n if n.amount.is > 100 => SalesA
    case _ => SalesB
  }
}

def recentTags = Tag.findAllByPreparedStatement({ superconn =>
  superconn.connection.prepareStatement(
    "select distinct Expense.id, Tag.name" +
    "from Tag" +
    "join ExpenseTag et on Tag.id = et.tag " +
    "join Expense ex on ex.id = et.expense " +
    "where ex.dateOf > (CURRENT_DATE - interval ’30 days’)")
})

DB.runQuery("select Tag.name, sum(amount) from Expense ex " +
            "join ExpenseTag et on et.expense = ex.id " +
            "join Tag on et.tag = Tag.id " +
            "join Account on Account.id = ex.account " +
            "where Account.id = ? group by Tag.name order by Tag.name",
            myAccount.id)
// might return:
(List("tag", "sum"]),
 List(List("food","42.00"),
      List("home","75.49"),
      List("work","2.00")))

// recompute an account balance from all of the transactions
DB.use(DefaultConnectionIdentifier) { conn =>
  val balance = 
    // Should use a prepared statement here. This is for example only
    DB.exec(conn, 
      "select sum(ex.amount) from Expense ex where ex.account = " 
      + myAccount.id) {
      rs => 
       if (!rs.next) BigDecimal(0) 
       else (new BigDecimal(rs.getBigDecimal(1)))
    }
  DB.prepareStatement("update Account set balance = ? where Account.id = ", 
                      conn) { stmt =>
    stmt.setBigDecimal(1, balance.bigDecimal)
    stmt.setLong(2, resetAccount.id)
    stmt.executeUpdate()
  }
}