CRUDify

abstract def idFromString(in: String): K

abstract def table: Table[(CRUDify.this)#TheCrudType]

final def !=(arg0: Any): Boolean

final def ##(): Int

final 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

The core template for creating.

def _deleteTemplate: Elem

The core template for deleting.

def _editTemplate: Elem

The core template for editing.

def _showAllTemplate: Elem

The core template for showing record.

def _viewTemplate: Elem

The core template for viewing.

def addlMenuLocParams: List[AnyLocParam]

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)

final def asInstanceOf[T0]: T0

def buildBridge(in: (CRUDify.this)#TheCrudType): (CRUDify.this)#SquerylBridge

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

def buildFieldBridge(from: (CRUDify.this)#FieldPointerType): (CRUDify.this)#FieldPointerBridge

Based on a FieldPointer, build a FieldPointerBridge

def calcCreateItem: String

def calcDeleteItem: String

def calcEditItem: String

def calcListItems: String

def calcPrefix: List[String]

What's the prefix for this CRUD.

def calcViewItem: String

def clone(): AnyRef

def computeFieldFromPointer(instance: (CRUDify.this)#TheCrudType, pointer: (CRUDify.this)#FieldPointerType): Box[(CRUDify.this)#FieldPointerType]

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

def create: T

Vend a new instance of TheCrudType

def createButton: String

def createClass: String

def createId: String

def createMenuLoc: Box[Menu]

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

def createMenuLocParams: List[AnyLocParam]

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.

def crudAllNext(first: Long, list: List[(CRUDify.this)#TheCrudType]): (NodeSeq) ⇒ NodeSeq

Override this method to change how the next link is generated

def crudAllPrev(first: Long): (NodeSeq) ⇒ NodeSeq

Override this method to change how the previous link is generated

def crudDoForm(item: (CRUDify.this)#TheCrudType, noticeMsg: String)(in: NodeSeq): NodeSeq

def crudyDelete(item: (CRUDify.this)#TheCrudType): (NodeSeq) ⇒ NodeSeq

Override this method to change how the delete screen is built

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)

def deleteMenuLocParams: List[LocParam[(CRUDify.this)#TheCrudType]]

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

def displayHtml: NodeSeq

def displayName: String

def displayRecord(entry: (CRUDify.this)#TheCrudType): (NodeSeq) ⇒ NodeSeq

Customize the display of records for view menu loc

def doCrudAll: (NodeSeq) ⇒ NodeSeq

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

def doCrudAllHeaderItems: (NodeSeq) ⇒ NodeSeq

Override this method to customize how header items are treated

def doCrudAllRowItem(c: (CRUDify.this)#TheCrudType): (NodeSeq) ⇒ NodeSeq

Override this method to customize how a crudAll line is generated

def doCrudAllRows(list: List[(CRUDify.this)#TheCrudType]): (NodeSeq) ⇒ NodeSeq

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

def doDeleteFields(item: (CRUDify.this)#TheCrudType): (NodeSeq) ⇒ NodeSeq

Override this method to change how fields are displayed for delete

def doDeleteSubmit(item: (CRUDify.this)#TheCrudType, from: String)(): Nothing

Override this method to change the behavior of deleting an item

def doDisplayRecordRow(entry: (CRUDify.this)#TheCrudType): (NodeSeq) ⇒ NodeSeq

Customize the display of a row for displayRecord

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)

def editMenuLocParams: List[LocParam[(CRUDify.this)#TheCrudType]]

Override to include new Params for the edit menu

def editMenuName: String

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fieldsForDisplay: List[(CRUDify.this)#FieldPointerType]

When displaying a record, what fields do we display

def fieldsForEditing: List[(CRUDify.this)#FieldPointerType]

The list of fields to present on a form form editing

def fieldsForList: List[(CRUDify.this)#FieldPointerType]

The fields displayed on the list page.

def finalize(): Unit

def findForList(start: Long, count: Int): List[(CRUDify.this)#TheCrudType]

Given a range, find the records.

def findForParam(in: String): Box[(CRUDify.this)#TheCrudType]

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

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

lazy val listPath: List[String]

lazy val listPathString: String

lazy val locSnippets: DispatchLocSnippets { val dispatch: PartialFunction[String,scala.xml.NodeSeq => scala.xml.NodeSeq] }

def menus: List[Menu]

final def ne(arg0: AnyRef): Boolean

def nextWord: String

final def notify(): Unit

final def notifyAll(): Unit

def obscurePrimaryKey(in: String): String

This method can be used to obscure the primary key.

def obscurePrimaryKey(in: (CRUDify.this)#TheCrudType): String

This method can be used to obscure 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.

def showAllClass: String

def showAllId: String

def showAllMenuLoc: Box[Menu]

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

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

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def viewClass: String

def viewId: String

def viewMenuLoc: Box[Menu]

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

def viewMenuLocParams: List[LocParam[(CRUDify.this)#TheCrudType]]

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

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def wrapNameInRequired(fieldName: NodeSeq, required: Boolean): NodeSeq

As the field names are being displayed for editing, this method is called with the XHTML that will be displayed as the field name and a flag indicating whether the field is required.