net.liftweb.proto.Crudify

Ordering

Alphabetic
By inheritance

Inherited

Hide All
Show all

Crudify
AnyRef
Any

Visibility

Public
All

Impl.

Concrete
Abstract

Type Members

trait CrudBridge extends AnyRef

This trait represents a Bridge between TheCrudType and the Crudify trait.
trait FieldPointerBridge extends AnyRef

attributes: protected
type FieldPointerType

A generic representation of a field.

A generic representation of a field. For example, this represents the abstract "name" field and is used along with an instance of TheCrudType to compute the BaseField that is the "name" field on the specific instance of TheCrudType
attributes: abstract
type TheCrudType

The type of records we're manipulating

The type of records we're manipulating
attributes: abstract

Value Members

def != (arg0: AnyRef) : Boolean

attributes: final
definition classes: AnyRef
def != (arg0: Any) : Boolean

o != arg0 is the same as !(o == (arg0)).

o != arg0 is the same as !(o == (arg0)).
arg0
the object to compare against this object for dis-equality.
returns
false if the receiver object is equivalent to the argument; true otherwise.
attributes: final
definition classes: Any
def ## () : Int

attributes: final
definition classes: AnyRef → Any
def $asInstanceOf [T0] () : T0

attributes: final
definition classes: AnyRef
def $isInstanceOf [T0] () : Boolean

attributes: final
definition classes: AnyRef
def == (arg0: AnyRef) : Boolean

o == arg0 is the same as if (o eq null) arg0 eq null else o.equals(arg0).

o == arg0 is the same as if (o eq null) arg0 eq null else o.equals(arg0).
arg0
the object to compare against this object for equality.
returns
true if the receiver object is equivalent to the argument; false otherwise.
attributes: final
definition classes: AnyRef
def == (arg0: Any) : Boolean

o == arg0 is the same as o.equals(arg0).

o == arg0 is the same as o.equals(arg0).
arg0
the object to compare against this object for equality.
returns
true if the receiver object is equivalent to the argument; false otherwise.
attributes: final
definition classes: Any
lazy val CreateItem : String
lazy val DeleteItem : String
lazy val EditItem : String
lazy val ListItems : String
lazy val Prefix : List[String]
lazy val ViewItem : String
def _createTemplate : Elem

The core template for creating.

The core template for creating. Does not include any page wrapping
def _deleteTemplate : Elem

The core template for deleting.

The core template for deleting. Does not include any page wrapping
def _editTemplate : Elem

The core template for editting.

The core template for editting. Does not include any page wrapping
attributes: protected
def _showAllTemplate : Elem

The core template for showing record.

The core template for showing record. Does not include any page wrapping
def _viewTemplate : Elem

The core template for viewing.

The core template for viewing. Does not include any page wrapping
def addlMenuLocParams : List[AnyLocParam]

If there are any Loc.

If there are any Loc.LocParams that need to be added to every menu (e.g., a guard for access control of the Crudify screens)
attributes: protected
def asInstanceOf [T0] : T0

This method is used to cast the receiver object to be of type T0.

This method is used to cast the receiver object to be of type T0.
Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression1.asInstanceOf[String] will throw a ClassCastException at runtime, while the expressionList(1).asInstanceOf[List[String]] will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested typed.
returns
the receiver object.
attributes: final
definition classes: Any
implicit def buildBridge (from: TheCrudType) : CrudBridge

This method will instantiate a bridge from TheCrudType so that the appropriate logical operations can be performed on TheCrudType

This method will instantiate a bridge from TheCrudType so that the appropriate logical operations can be performed on TheCrudType
attributes: protected implicit abstract
implicit def buildFieldBridge (from: FieldPointerType) : FieldPointerBridge

Based on a FieldPointer, build a FieldPointerBridge

Based on a FieldPointer, build a FieldPointerBridge
attributes: protected implicit abstract
def calcCreateItem : String
def calcDeleteItem : String
def calcEditItem : String
def calcListItems : String
def calcPrefix : List[String]

What's the prefix for this CRUD.

What's the prefix for this CRUD. Typically the table name
attributes: abstract
def calcViewItem : String
def clone () : AnyRef

This method creates and returns a copy of the receiver object.

This method creates and returns a copy of the receiver object.
The default implementation of the clone method is platform dependent.
returns
a copy of the receiver object.
attributes: protected
definition classes: AnyRef
def computeFieldFromPointer (instance: TheCrudType, pointer: FieldPointerType) : Box[BaseField]

Given an instance of TheCrudType and FieldPointerType, convert that to an actual instance of a BaseField on the instance of TheCrudType

Given an instance of TheCrudType and FieldPointerType, convert that to an actual instance of a BaseField on the instance of TheCrudType
attributes: protected abstract
def create : TheCrudType

Vend a new instance of TheCrudType

Vend a new instance of TheCrudType
attributes: abstract
def createButton : String
def createClass : String
def createId : String
def createMenuLoc : Box[Menu]

The menu item for creating items (make this "Empty" to disable)

The menu item for creating items (make this "Empty" to disable)
def createMenuLocParams : List[AnyLocParam]

Override to include new Params for the create menu

Override to include new Params for the create menu
def createMenuName : String
lazy val createPath : List[String]
lazy val createPathString : String
def createTemplate () : NodeSeq

This is the template that's used to render the page after the optional wrapping of the template in the page wrapper

This is the template that's used to render the page after the optional wrapping of the template in the page wrapper
def crudAllNext (first: Long, list: List[TheCrudType])(in: NodeSeq) : Node {...}

Override this method to change how the next link is generated

Override this method to change how the next link is generated
attributes: protected
def crudAllPrev (first: Long)(in: NodeSeq) : Node {...}

Override this method to change how the previous link is generated

Override this method to change how the previous link is generated
attributes: protected
def crudDoForm (item: TheCrudType, noticeMsg: String)(in: NodeSeq) : NodeSeq
def crudyDelete (item: TheCrudType)(html: NodeSeq) : NodeSeq

Override this method to change how the delete screen is built

Override this method to change how the delete screen is built
attributes: protected
def deleteButton : String
def deleteClass : String
def deleteId : String
def deleteMenuLoc : Box[Menu]

The menu item for deleting an item (make this "Empty" to disable)

The menu item for deleting an item (make this "Empty" to disable)
def deleteMenuLocParams : List[LocParam[TheCrudType]]

Override to include new Params for the delete menu

Override to include new Params for the delete menu
def deleteMenuName : String
lazy val deletePath : List[String]
lazy val deletePathString : String
def deleteTemplate () : NodeSeq

This is the template that's used to render the page after the optional wrapping of the template in the page wrapper

This is the template that's used to render the page after the optional wrapping of the template in the page wrapper
def displayHtml : NodeSeq
def displayName : String
def displayRecord (entry: TheCrudType)(in: NodeSeq) : NodeSeq

Customize the display of records for view menu loc

Customize the display of records for view menu loc
attributes: protected
def doCrudAll (in: NodeSeq) : NodeSeq

Override this method if you want to change the behavior of displaying records via the crud.

Override this method if you want to change the behavior of displaying records via the crud.all snippet
attributes: protected
def doCrudAllHeaderItems (in: NodeSeq) : NodeSeq

Override this method to customize how header items are treated

Override this method to customize how header items are treated
attributes: protected
def doCrudAllRowItem (c: TheCrudType)(in: NodeSeq) : NodeSeq

Override this method to customize how a crudAll line is generated

Override this method to customize how a crudAll line is generated
attributes: protected
def doCrudAllRows (list: List[TheCrudType])(in: NodeSeq) : NodeSeq

Override this method to determine how all the rows on a crud page are displayed

Override this method to determine how all the rows on a crud page are displayed
attributes: protected
def doDeleteFields (item: TheCrudType)(html: NodeSeq) : NodeSeq

Override this method to change how fields are displayed for delete

Override this method to change how fields are displayed for delete
attributes: protected
def doDeleteSubmit (item: TheCrudType, from: String)() : Nothing

Override this method to change the behavior of deleting an item

Override this method to change the behavior of deleting an item
attributes: protected
def doDisplayRecordRow (entry: TheCrudType)(in: NodeSeq) : NodeSeq

Customize the display of a row for displayRecord

Customize the display of a row for displayRecord
attributes: protected
def editButton : String
def editClass : String
def editErrorClass : String
def editId : String
def editMenuLoc : Box[Menu]

The menu item for editing an item (make this "Empty" to disable)

The menu item for editing an item (make this "Empty" to disable)
def editMenuLocParams : List[LocParam[TheCrudType]]

Override to include new Params for the edit menu

Override to include new Params for the edit menu
def editMenuName : String

The String displayed for menu editing

The String displayed for menu editing
lazy val editPath : List[String]
lazy val editPathString : String
def editTemplate () : NodeSeq

This is the template that's used to render the page after the optional wrapping of the template in the page wrapper

This is the template that's used to render the page after the optional wrapping of the template in the page wrapper
def eq (arg0: AnyRef) : Boolean

This method is used to test whether the argument (arg0) is a reference to the receiver object (this).

This method is used to test whether the argument (arg0) is a reference to the receiver object (this).
The eq method implements an [http://en.wikipedia.org/wiki/Equivalence_relation equivalence relation] on non-null instances of AnyRef: * It is reflexive: for any non-null instance x of type AnyRef, x.eq(x) returns true. * It is symmetric: for any non-null instances x and y of type AnyRef, x.eq(y) returns true if and only if y.eq(x) returns true. * It is transitive: for any non-null instances x, y, and z of type AnyRef if x.eq(y) returns true and y.eq(z) returns true, then x.eq(z) returns true.
Additionally, the eq method has three other properties. * It is consistent: for any non-null instances x and y of type AnyRef, multiple invocations of x.eq(y) consistently returns true or consistently returns false. * For any non-null instance x of type AnyRef, x.eq(null) and null.eq(x) returns false. * null.eq(null) returns true.
When overriding the equals or hashCode methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2), they should be equal to each other (o1 == o2) and they should hash to the same value (o1.hashCode == o2.hashCode).
arg0
the object to compare against this object for reference equality.
returns
true if the argument is a reference to the receiver object; false otherwise.
attributes: final
definition classes: AnyRef
def equals (arg0: Any) : Boolean

This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence.

This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence.
The default implementations of this method is an [http://en.wikipedia.org/wiki/Equivalence_relation equivalence relation]: * It is reflexive: for any instance x of type Any, x.equals(x) should return true. * It is symmetric: for any instances x and y of type Any, x.equals(y) should return true if and only if y.equals(x) returns true. * It is transitive: for any instances x, y, and z of type AnyRef if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
If you override this method, you should verify that your implementation remains an equivalence relation. Additionally, when overriding this method it is often necessary to override hashCode to ensure that objects that are "equal" (o1.equals(o2) returns true) hash to the same scala.Int (o1.hashCode.equals(o2.hashCode)).
arg0
the object to compare against this object for equality.
returns
true if the receiver object is equivalent to the argument; false otherwise.
definition classes: AnyRef → Any
def fieldsForDisplay : List[FieldPointerType]

When displaying a record, what fields do we display

When displaying a record, what fields do we display
attributes: abstract
def fieldsForEditing : List[FieldPointerType]

The list of fields to present on a form form editting

The list of fields to present on a form form editting
def fieldsForList : List[FieldPointerType]

The fields displayed on the list page.

The fields displayed on the list page. By default all the displayed fields, but this list can be shortened.
def finalize () : Unit

This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.

This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.
The details of when and if the finalize method are invoked, as well as the interaction between finalizeand non-local returns and exceptions, are all platform dependent.
attributes: protected
definition classes: AnyRef
def findForList (start: Long, count: Int) : List[TheCrudType]

Given a range, find the records.

Given a range, find the records. Your implementation of this method should enforce ordering (e.g., on primary key)
attributes: abstract
def findForParam (in: String) : Box[TheCrudType]

Given a String that represents the primary key, find an instance of TheCrudType

Given a String that represents the primary key, find an instance of TheCrudType
attributes: abstract
def getClass () : java.lang.Class[_]

Returns a representation that corresponds to the dynamic class of the receiver object.

Returns a representation that corresponds to the dynamic class of the receiver object.
The nature of the representation is platform dependent.
returns
a representation that corresponds to the dynamic class of the receiver object.
attributes: final
definition classes: AnyRef
def hashCode () : Int

Returns a hash code value for the object.

Returns a hash code value for the object.
The default hashing algorithm is platform dependent.
Note that it is allowed for two objects to have identical hash codes (o1.hashCode.equals(o2.hashCode)) yet not be equal (o1.equals(o2) returns false). A degenerate implementation could always return 0. However, it is required that if two objects are equal (o1.equals(o2) returns true) that they have identical hash codes (o1.hashCode.equals(o2.hashCode)). Therefore, when overriding this method, be sure to verify that the behavior is consistent with the equals method.
returns
the hash code value for the object.
definition classes: AnyRef → Any
def isInstanceOf [T0] : Boolean

This method is used to test whether the dynamic type of the receiver object is T0.

This method is used to test whether the dynamic type of the receiver object is T0.
Note that the test result of the test is modulo Scala's erasure semantics. Therefore the expression1.isInstanceOf[String] will return false, while the expression List(1).isInstanceOf[List[String]] will return true. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested typed.
returns
true if the receiver object is an instance of erasure of type T0; false otherwise.
attributes: final
definition classes: Any
lazy val listPath : List[String]
lazy val listPathString : String
lazy val locSnippets : DispatchLocSnippets
def menus : List[Menu]
def ne (arg0: AnyRef) : Boolean

o.ne(arg0) is the same as !(o.eq(arg0)).

o.ne(arg0) is the same as !(o.eq(arg0)).
arg0
the object to compare against this object for reference dis-equality.
returns
false if the argument is not a reference to the receiver object; true otherwise.
attributes: final
definition classes: AnyRef
def nextWord : String
def notify () : Unit

Wakes up a single thread that is waiting on the receiver object's monitor.

Wakes up a single thread that is waiting on the receiver object's monitor.
attributes: final
definition classes: AnyRef
def notifyAll () : Unit

Wakes up all threads that are waiting on the receiver object's monitor.

Wakes up all threads that are waiting on the receiver object's monitor.
attributes: final
definition classes: AnyRef
def obscurePrimaryKey (in: String) : String

This method can be used to obscure the primary key.

This method can be used to obscure the primary key. This is more secure because end users will not have access to the primary key. This method actually does the obfuscation. You can use Mapper's KeyObfuscator class to implement a nice implementation of this method for session-by-session obfuscation.

By default, there's no obfuscation. Note that if you obfuscate the primary key, you need to update the findForParam method to accept the obfuscated keys (and translate them back.)
def obscurePrimaryKey (in: TheCrudType) : String

This method can be used to obscure the primary key.

This method can be used to obscure the primary key. This is more secure because end users will not have access to the primary key.
def pageWrapper (body: NodeSeq) : NodeSeq
def previousWord : String
def referer : String
def rowsPerPage : Int

This method defines how many rows are displayed per page.

This method defines how many rows are displayed per page. By default, it's hard coded at 20, but you can make it session specific or change the default by overriding this method
attributes: protected
def showAllClass : String
def showAllId : String
def showAllMenuLoc : Box[Menu]

The menu item for listing items (make this "Empty" to disable)

The menu item for listing items (make this "Empty" to disable)
def showAllMenuLocParams : List[AnyLocParam]

Override to include new Params for the show all menu

Override to include new Params for the show all menu
def showAllMenuName : String
def showAllTemplate () : NodeSeq

This is the template that's used to render the page after the optional wrapping of the template in the page wrapper

This is the template that's used to render the page after the optional wrapping of the template in the page wrapper
def synchronized [T0] (arg0: T0) : T0

attributes: final
definition classes: AnyRef
def toString () : String

Returns a string representation of the object.

Returns a string representation of the object.
The default representation is platform dependent.
returns
a string representation of the object.
definition classes: AnyRef → Any
def viewClass : String
def viewId : String
def viewMenuLoc : Box[Menu]

The menu item for viewing an item (make this "Empty" to disable)

The menu item for viewing an item (make this "Empty" to disable)
def viewMenuLocParams : List[LocParam[TheCrudType]]

Override to include new Params for the view menu

Override to include new Params for the view menu
def viewMenuName : String
lazy val viewPath : List[String]
lazy val viewPathString : String
def viewTemplate () : NodeSeq

This is the template that's used to render the page after the optional wrapping of the template in the page wrapper

This is the template that's used to render the page after the optional wrapping of the template in the page wrapper
def wait () : Unit

attributes: final
definition classes: AnyRef
def wait (arg0: Long, arg1: Int) : Unit

attributes: final
definition classes: AnyRef
def wait (arg0: Long) : Unit

attributes: final
definition classes: AnyRef
def wrapNameInRequired (fieldName: NodeSeq, required: Boolean) : NodeSeq

As the field names are being displayed for editting, this method is called with the XHTML that will be displayed as the field name an a flag indicating that the field is required (or not).

As the field names are being displayed for editting, this method is called with the XHTML that will be displayed as the field name an a flag indicating that the field is required (or not). You can wrap the fieldName in a span with a css class indicating that the field is required or otherwise do something to update the field name indiciating to the user that the field is required. By default the method wraps the fieldName in a span with the class attribute set to "required_field"

Crudify

trait Crudify extends AnyRef

Type Members

trait CrudBridge extends AnyRef

trait FieldPointerBridge extends AnyRef

type FieldPointerType

type TheCrudType

Value Members

def != (arg0: AnyRef) : Boolean

def != (arg0: Any) : Boolean

def ## () : Int

def $asInstanceOf [T0] () : T0

def $isInstanceOf [T0] () : Boolean

def == (arg0: AnyRef) : Boolean

def == (arg0: Any) : Boolean

lazy val CreateItem : String

lazy val DeleteItem : String

lazy val EditItem : String

lazy val ListItems : String

lazy val Prefix : List[String]

lazy val ViewItem : String

def _createTemplate : Elem

def _deleteTemplate : Elem

def _editTemplate : Elem

def _showAllTemplate : Elem

def _viewTemplate : Elem

def addlMenuLocParams : List[AnyLocParam]

def asInstanceOf [T0] : T0

implicit def buildBridge (from: TheCrudType) : CrudBridge

implicit def buildFieldBridge (from: FieldPointerType) : FieldPointerBridge

def calcCreateItem : String

def calcDeleteItem : String

def calcEditItem : String

def calcListItems : String

def calcPrefix : List[String]

def calcViewItem : String

def clone () : AnyRef

def computeFieldFromPointer (instance: TheCrudType, pointer: FieldPointerType) : Box[BaseField]

def create : TheCrudType

def createButton : String

def createClass : String

def createId : String

def createMenuLoc : Box[Menu]

def createMenuLocParams : List[AnyLocParam]

def createMenuName : String

lazy val createPath : List[String]

lazy val createPathString : String

def createTemplate () : NodeSeq

def crudAllNext (first: Long, list: List[TheCrudType])(in: NodeSeq) : Node {...}

def crudAllPrev (first: Long)(in: NodeSeq) : Node {...}

def crudDoForm (item: TheCrudType, noticeMsg: String)(in: NodeSeq) : NodeSeq

def crudyDelete (item: TheCrudType)(html: NodeSeq) : NodeSeq

def deleteButton : String

def deleteClass : String

def deleteId : String

def deleteMenuLoc : Box[Menu]

def deleteMenuLocParams : List[LocParam[TheCrudType]]

def deleteMenuName : String

lazy val deletePath : List[String]

lazy val deletePathString : String

def deleteTemplate () : NodeSeq

def displayHtml : NodeSeq

def displayName : String

def displayRecord (entry: TheCrudType)(in: NodeSeq) : NodeSeq

def doCrudAll (in: NodeSeq) : NodeSeq

def doCrudAllHeaderItems (in: NodeSeq) : NodeSeq

def doCrudAllRowItem (c: TheCrudType)(in: NodeSeq) : NodeSeq

def doCrudAllRows (list: List[TheCrudType])(in: NodeSeq) : NodeSeq

def doDeleteFields (item: TheCrudType)(html: NodeSeq) : NodeSeq

def doDeleteSubmit (item: TheCrudType, from: String)() : Nothing

def doDisplayRecordRow (entry: TheCrudType)(in: NodeSeq) : NodeSeq

def editButton : String

def editClass : String

def editErrorClass : String

def editId : String

def editMenuLoc : Box[Menu]

def editMenuLocParams : List[LocParam[TheCrudType]]

def editMenuName : String

lazy val editPath : List[String]

lazy val editPathString : String