CRUDify

abstract def create: (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

def _deleteTemplate: Elem

def _editTemplate: Elem

def _showAllTemplate: Elem

def _viewTemplate: Elem

def addlMenuLocParams: List[AnyLocParam]

final def asInstanceOf[T0]: T0

implicit def buildBridge(from: (CRUDify.this)#TheCrudType): (CRUDify.this)#CrudBridge

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

implicit 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[BaseField]

Given a field pointer and an instance, get the field on that instance

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[(CRUDify.this)#TheCrudType]): (NodeSeq) ⇒ NodeSeq

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

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

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

def deleteButton: String

def deleteClass: String

def deleteId: String

def deleteMenuLoc: Box[Menu]

def deleteMenuLocParams: List[LocParam[(CRUDify.this)#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: (CRUDify.this)#TheCrudType): (NodeSeq) ⇒ NodeSeq

def doCrudAll: (NodeSeq) ⇒ NodeSeq

def doCrudAllHeaderItems: (NodeSeq) ⇒ NodeSeq

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

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

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

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

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

def editButton: String

def editClass: String

def editErrorClass: String

def editId: String

def editMenuLoc: Box[Menu]

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

def editMenuName: String

lazy val editPath: List[String]

lazy val editPathString: String

def editTemplate(): NodeSeq

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fieldsForDisplay: List[MappedField[_, CrudType]]

The fields to be displayed.

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

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

def finalize(): Unit

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

Get a List of items from the databased

def findForListParams: List[QueryParam[CrudType]]

What are the query parameters? Default to ascending on primary key

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

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

def pageWrapper(body: NodeSeq): NodeSeq

def previousWord: String

def referer: String

def rowsPerPage: Int

def showAllClass: String

def showAllId: String

def showAllMenuLoc: Box[Menu]

def showAllMenuLocParams: List[AnyLocParam]

def showAllMenuName: String

def showAllTemplate(): NodeSeq

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

def toString(): String

def viewClass: String

def viewId: String

def viewMenuLoc: Box[Menu]

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

def viewMenuName: String

lazy val viewPath: List[String]

lazy val viewPathString: String

def viewTemplate(): NodeSeq

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