MetaLDAPProtoUser

def getSingleton : KeyedMetaMapper[Long, ModelType]

def primaryKeyField : MappedField[Long, ModelType] with IndexedField[Long]

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

object AddUserMenusAfter extends LocParam[Any] with Product with Serializable

Insert this LocParam into your menu if you want the User's menu items to be inserted at the same level and after the item

object AddUserMenusHere extends LocParam[Any] with Product with Serializable

replace the menu that has this LocParam with the User's menu items

object AddUserMenusUnder extends LocParam[Any] with Product with Serializable

Insert this LocParam into your menu if you want the User's menu items to be children of that menu

lazy val ItemList : List[MenuItem]

def _dbTableNameLC : String

The table name, to lower case.

def actionsAfterSignup (theUser: TheUserType, func: () ⇒ Nothing): Nothing

Override this method to do something else after the user signs up

def addEndStuffs (in: String, params: List[QueryParam[ModelType]], conn: SuperConnection): (String, Box[Long], Box[Long])

def addSnippet (xhtml: NodeSeq): NodeSeq

Default add snippet.

def addSnippetCallback (obj: ModelType): Unit

Default callback behavior of the add snippet.

def addSnippetSetup : ModelType

Default setup behavior for the add snippet.

object addlQueryParams extends RequestVar[List[QueryParam[A]]]

def afterCommit : List[(ModelType) ⇒ Unit]

def afterCreate : List[(ModelType) ⇒ Unit]

def afterDelete : List[(ModelType) ⇒ Unit]

def afterSave : List[(ModelType) ⇒ Unit]

def afterSchemifier : Unit

def afterUpdate : List[(ModelType) ⇒ Unit]

def afterValidation : List[(ModelType) ⇒ Unit]

def afterValidationOnCreate : List[(ModelType) ⇒ Unit]

def afterValidationOnUpdate : List[(ModelType) ⇒ Unit]

def allFields : Seq[BaseField]

def appendField (pf: FieldPF): Unit

def appendFieldToStrings (in: ModelType): String

def asHtml (toLine: ModelType): NodeSeq

def asHtml : NodeSeq

def asInstanceOf [T0] : T0

def asJs (actual: ModelType): JsExp

def asJs : JsExp

Convert the model to a JavaScript object

def asSafeJs (actual: ModelType, f: KeyObfuscator): JsExp

def asSafeJs (f: KeyObfuscator): JsExp

def asValid : Box[ModelType]

Returns the instance in a Full Box if the instance is valid, otherwise returns a Failure with the validation errors

var autologinFunc : Box[() ⇒ Unit]

This function is given a chance to log in a user programmatically when needed

def basePath : List[String]

The base path for the user related URLs.

def bccEmail : Box[String]

def beforeCreate : List[(ModelType) ⇒ Unit]

def beforeDelete : List[(ModelType) ⇒ Unit]

def beforeSave : List[(ModelType) ⇒ Unit]

def beforeSchemifier : Unit

def beforeUpdate : List[(ModelType) ⇒ Unit]

def beforeValidation : List[(ModelType) ⇒ Unit]

def beforeValidationOnCreate : List[(ModelType) ⇒ Unit]

def beforeValidationOnUpdate : List[(ModelType) ⇒ Unit]

def bindAttributes (attrs: Attributes): Unit

implicit def boundedFieldToItem (in: (MappedField[String, ModelType], Int)): BoundedIndexField[ModelType]

implicit def buildFieldBridge (from: FieldPointerType): FieldPointerBridge

Based on a FieldPointer, build a FieldPointerBridge

def buildMapper (rs: ResultSet): List[Box[(ResultSet, Int, ModelType) ⇒ Unit]]

def buildSelectString (fields: Seq[SelectableField], conn: SuperConnection, by: QueryParam[ModelType]*): (String, Box[Long], Box[Long], List[QueryParam[ModelType]])

Given fields, a connection and the query parameters, build a query and return the query String, and Start or MaxRows values (depending on whether the driver supports LIMIT and OFFSET) and the complete List of QueryParams based on any synthetic query parameters calculated during the query creation.

def bulkDelete_!! (dbId: ConnectionIdentifier, by: QueryParam[ModelType]*): Boolean

def bulkDelete_!! (by: QueryParam[ModelType]*): Boolean

def capturePreLoginState (): () ⇒ Unit

If there's any state that you want to capture pre-login to be set post-login (the session is destroyed), then set the state here.

def changePassword : NodeSeq

def changePasswordMenuLoc : Box[Menu]

The menu item for changing password (make this "Empty" to disable)

def changePasswordMenuLocParams : List[LocParam[Unit]]

The LocParams for the menu item for changing password.

lazy val changePasswordPath : List[String]

The computed path for change password screen

def changePasswordSuffix : String

The path suffix for the change password screen

def changePasswordXhtml : Elem

def checkNames : Unit

def clean_? (toCheck: ModelType): Boolean

Returns true if none of the fields are dirty

def clone (): AnyRef

val columnNamesForInsert : String

def columnPrimaryKey_? (name: String): Boolean

This method returns true if the named column is the primary key and it is autogenerated

val columnQueriesForInsert : String

def commonNameAttributeName : String

def comparePrimaryKeys (other: ModelType): Boolean

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

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

def connectionIdentifier : ConnectionIdentifier

def connectionIdentifier (id: ConnectionIdentifier): ModelType

def count (by: QueryParam[ModelType]*): Long

def count : Long

def countByInsecureSql (query: String, checkedBy: IHaveValidatedThisSQL): Long

def countByInsecureSqlDb (dbId: ConnectionIdentifier, query: String, checkedBy: IHaveValidatedThisSQL): Long

def countDb (dbId: ConnectionIdentifier, by: QueryParam[ModelType]*): Long

def countryField : Box[MappedCountry[ModelType]]

def create : ModelType

def createInstance : ModelType

def createInstance (dbId: ConnectionIdentifier, rs: ResultSet, mapFuncs: List[Box[(ResultSet, Int, ModelType) ⇒ Unit]]): ModelType

def createInstances [T] (dbId: ConnectionIdentifier, rs: ResultSet, start: Box[Long], omax: Box[Long], f: (ModelType) ⇒ Box[T]): List[T]

def createInstances (dbId: ConnectionIdentifier, rs: ResultSet, start: Box[Long], omax: Box[Long]): List[ModelType]

def createNewUserInstance (): TheUserType

Create a new instance of the User

def createUserMenuLoc : Box[Menu]

The menu item for creating the user/sign up (make this "Empty" to disable)

def createUserMenuLocParams : List[LocParam[Unit]]

The LocParams for the menu item for creating the user/sign up.

def crudSnippets : SnippetPF

Defines the default CRUD snippets.

def crudSnippets_? : Boolean

Override this definition in your model to enable CRUD snippets for that model.

def currentUser : Box[TheUserType]

def currentUserId : Box[String]

def dbAddTable : Box[() ⇒ Unit]

def dbCalculateConnectionIdentifier : PartialFunction[ModelType, ConnectionIdentifier]

def dbDefaultConnectionIdentifier : ConnectionIdentifier

def dbIndexes : List[BaseIndex[ModelType]]

def dbName : String

The name of the mapped object

def dbSelectDBConnectionForFind : PartialFunction[Long, ConnectionIdentifier]

def dbStringToKey (in: String): Box[Long]

def dbTableName : String

The name of the database table.

def db_can_delete_? : Boolean

Can this model object be deleted?

def decodeFromJSON_! (json: JObject, markFieldsAsDirty: Boolean): ModelType

Decode the fields from a JSON Object.

def delete_! (toDelete: ModelType): Boolean

def delete_! : Boolean

Delete the model from the RDBMS

def destroySessionOnLogin : Boolean

By default, destroy the session on login.

def dirty_? (toTest: ModelType): Boolean

def dirty_? : Boolean

var displayFieldAsLineElement : (NodeSeq) ⇒ NodeSeq

This function converts an element into the appropriate XHTML format for displaying across a line formatted block.

var displayNameToHeaderElement : (String) ⇒ NodeSeq

This function converts a header name into the appropriate XHTML format for displaying across the headers of a formatted block.

def doHtmlLine (toLine: ModelType): NodeSeq

def doPostCommit (func: () ⇒ Unit): ModelType

Append a function to perform after the commit happens

def edit : NodeSeq

def editFields : List[FieldPointerType]

The list of fields presented to the user for editing

object editFunc extends RequestVar[Box[() ⇒ NodeSeq]]

lazy val editPath : List[String]

The computed path for the edit screen

def editSnippet (xhtml: NodeSeq): NodeSeq

Default edit snippet.

def editSnippetCallback (obj: ModelType): Unit

Default callback behavior of the edit snippet.

def editSnippetSetup : ModelType

Default setup behavior for the edit snippet.

def editSuffix : String

The path suffix for the edit screen

def editUserMenuLoc : Box[Menu]

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

def editUserMenuLocParams : List[LocParam[Unit]]

The LocParams for the menu item for editing the user.

def editXhtml (user: TheUserType): Elem

val elemName : String

def emailFrom : String

def encodeAsJSON_! (toEncode: ModelType): JObject

This method will encode the instance as JSON.

def eq (arg0: AnyRef): Boolean

def equals (other: Any): Boolean

def fieldByName [T] (fieldName: String, actual: ModelType): Box[MappedField[T, ModelType]]

Get a field by the field name

def fieldByName [T] (fieldName: String): Box[MappedField[T, ModelType]]

Find the field by name

def fieldMapperPF (transform: (BaseOwnedMappedField[ModelType]) ⇒ NodeSeq, actual: ModelType): PartialFunction[String, (NodeSeq) ⇒ NodeSeq]

def fieldMapperPF (transform: (BaseOwnedMappedField[ModelType]) ⇒ NodeSeq): FieldPF

lazy val fieldMatcher : PartialFunction[(ModelType, String), MappedField[Any, ModelType]]

A partial function that takes an instance of A and a field name and returns the mapped field

def fieldOrder : List[FieldPointerType]

def fieldPF : FieldPF

implicit def fieldToItem [T] (in: MappedField[T, ModelType]): IndexItem[ModelType]

def finalize (): Unit

def find (by: QueryParam[ModelType]*): Box[ModelType]

def find (dbId: ConnectionIdentifier, key: String): Box[ModelType]

def find (key: String): Box[ModelType]

def find (key: List[String]): Box[ModelType]

Find the element based on the first element of the List

def find (key: Any): Box[ModelType]

def findAll (by: QueryParam[ModelType]*): List[ModelType]

def findAll (): List[ModelType]

def findAllByInsecureSql (query: String, checkedBy: IHaveValidatedThisSQL): List[ModelType]

def findAllByInsecureSqlDb (dbId: ConnectionIdentifier, query: String, checkedBy: IHaveValidatedThisSQL): List[ModelType]

def findAllByPreparedStatement (dbId: ConnectionIdentifier, stmt: PreparedStatement): List[ModelType]

def findAllByPreparedStatement (f: (SuperConnection) ⇒ PreparedStatement): List[ModelType]

Execute a PreparedStatement and return a List of Mapper instances.

def findAllByPreparedStatementDb [T] (dbId: ConnectionIdentifier, stmt: PreparedStatement)(f: (ModelType) ⇒ Box[T]): List[T]

def findAllDb (dbId: ConnectionIdentifier, by: QueryParam[ModelType]*): List[ModelType]

def findAllDb (dbId: ConnectionIdentifier): List[ModelType]

def findAllFields (fields: Seq[SelectableField], by: QueryParam[ModelType]*): List[ModelType]

def findAllFieldsDb (dbId: ConnectionIdentifier, fields: Seq[SelectableField], by: QueryParam[ModelType]*): List[ModelType]

def findApplier (name: String, inst: AnyRef): Box[(ModelType, AnyRef) ⇒ Unit]

def findByKey (key: Long): Box[ModelType]

def findDb (dbId: ConnectionIdentifier, fields: Seq[SelectableField], by: QueryParam[ModelType]*): Box[ModelType]

def findDb (dbId: ConnectionIdentifier, by: QueryParam[ModelType]*): Box[ModelType]

def findDb (dbId: ConnectionIdentifier, key: Any): Box[ModelType]

def findDbByKey (dbId: ConnectionIdentifier, fields: Seq[SelectableField], key: Long): Box[ModelType]

def findDbByKey (dbId: ConnectionIdentifier, key: Long): Box[ModelType]

def findMap [T] (by: QueryParam[ModelType]*)(f: (ModelType) ⇒ Box[T]): List[T]

def findMapByInsecureSql [T] (query: String, checkedBy: IHaveValidatedThisSQL)(f: (ModelType) ⇒ Box[T]): List[T]

def findMapByInsecureSqlDb [T] (dbId: ConnectionIdentifier, query: String, checkedBy: IHaveValidatedThisSQL)(f: (ModelType) ⇒ Box[T]): List[T]

def findMapDb [T] (dbId: ConnectionIdentifier, by: QueryParam[ModelType]*)(f: (ModelType) ⇒ Box[T]): List[T]

def findMapFieldDb [T] (dbId: ConnectionIdentifier, fields: Seq[SelectableField], by: QueryParam[ModelType]*)(f: (ModelType) ⇒ Box[T]): List[T]

def findOrCreate (key: List[String]): ModelType

Find an element by primary key or create a new one

def findOrCreate (key: Any): ModelType

Find an element by primary key or create a new one

def findUserByUniqueId (id: String): Box[TheUserType]

Given a unique id, find the user

def findUserByUserName (email: String): Box[TheUserType]

Given an username (probably email address), find the user

def flatMapFieldTitleForm [T] (toMap: ModelType, func: (NodeSeq, Box[NodeSeq], NodeSeq) ⇒ Seq[T]): List[T]

flat map the fields titles and forms to generate a list

def flatMapFieldTitleForm [T] (func: (NodeSeq, Box[NodeSeq], NodeSeq) ⇒ Seq[T]): List[T]

flat map the fields titles and forms to generate a list

def flatMapFieldTitleForm2 [T] (toMap: ModelType, func: (NodeSeq, net.liftweb.mapper.MappedField[_, ModelType], NodeSeq) ⇒ Seq[T]): List[T]

flat map the fields titles and forms to generate a list

def flatMapFieldTitleForm2 [T] (func: (NodeSeq, net.liftweb.mapper.MappedField[_, ModelType], NodeSeq) ⇒ Seq[T]): List[T]

flat map the fields titles and forms to generate a list

def formFields (toMap: ModelType): List[net.liftweb.mapper.MappedField[_, ModelType]]

Get the fields (in order) for displaying a form

def formFields : List[net.liftweb.mapper.MappedField[_, ModelType]]

Get the fields (in order) for displaying a form

var formatFormElement : (NodeSeq, NodeSeq) ⇒ NodeSeq

This function converts a name and form for a given field in the model to XHTML for presentation in the browser.

def formatFormLine (displayName: NodeSeq, form: NodeSeq): NodeSeq

def generateResetEmailBodies (user: TheUserType, resetLink: String): List[MailBodyType]

Generate the mail bodies to send with the password reset link.

def generateValidationEmailBodies (user: TheUserType, resetLink: String): List[MailBodyType]

Generate the mail bodies to send with the valdiation link.

def getActualBaseField (actual: ModelType, protoField: BaseOwnedMappedField[ModelType]): BaseOwnedMappedField[ModelType]

Given the prototype field (the field on the Singleton), get the field from the instance

def getActualField [T] (actual: ModelType, protoField: MappedField[T, ModelType]): MappedField[T, ModelType]

Given the prototype field (the field on the Singleton), get the field from the instance

def getClass (): java.lang.Class[_]

def globalUserLocParams : List[LocParam[Unit]]

If you want to include a LocParam (e.

def hashCode (): Int

def homePage : String

The application's home page

def htmlHeaders : NodeSeq

def htmlLine : NodeSeq

def indexedField (toSave: ModelType): Box[MappedField[Any, ModelType]]

def isInstanceOf [T0] : Boolean

def ldapLogin (username: String, password: String): Boolean

def ldapUserSearch : String

User search sentence

def ldapVendor : LDAPVendor

def localForm (user: TheUserType, ignorePassword: Boolean, fields: List[FieldPointerType]): NodeSeq

def localeField : Box[MappedLocale[ModelType]]

If there's a field in this record that defines the locale, return it

def logUserIdIn (id: String): Unit

def logUserIn (who: TheUserType): Unit

def logUserIn (who: TheUserType, postLogin: () ⇒ Nothing): Nothing

def logUserOut (): Unit

def loggedIn_? : Boolean

def login : NodeSeq

def loginErrorMessage : String

Error messages

def loginFirst : If

A Menu.

def loginMenuLoc : Box[Menu]

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

def loginMenuLocParams : List[LocParam[Unit]]

The LocParams for the menu item for login.

def loginPageURL : String

Return the URL of the "login" page

lazy val loginPath : List[String]

The computed path for the login screen

object loginRedirect extends SessionVar[Box[String]]

If you want to redirect a user to a different page after login, put the page here

def loginSuffix : String

The path suffix for the login screen

def loginXhtml : Elem

def logout : Nothing

def logoutCurrentUser : Unit

def logoutMenuLoc : Box[Menu]

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

def logoutMenuLocParams : List[LocParam[Unit]]

The LocParams for the menu item for logout.

lazy val logoutPath : List[String]

The computed pat for logout

def logoutSuffix : String

The path suffix for the logout screen

def lostPassword : NodeSeq

def lostPasswordMenuLoc : Box[Menu]

The menu item for lost password (make this "Empty" to disable)

def lostPasswordMenuLocParams : List[LocParam[Unit]]

The LocParams for the menu item for lost password.

lazy val lostPasswordPath : List[String]

The computed path for the lost password screen

def lostPasswordSuffix : String

The path suffix for the lost password screen

def lostPasswordXhtml : Elem

def mapFieldTitleForm [T] (toMap: ModelType, func: (NodeSeq, Box[NodeSeq], NodeSeq) ⇒ T): List[T]

map the fields titles and forms to generate a list

def mapFieldTitleForm [T] (func: (NodeSeq, Box[NodeSeq], NodeSeq) ⇒ T): List[T]

map the fields titles and forms to generate a list

lazy val mappedFields : Seq[BaseMappedField]

The mapped fields

lazy val mappedFieldsForModel : List[net.liftweb.mapper.MappedField[_, ModelType]]

the mapped fields as MappedField rather than BaseMappedField

def menuNameSuffix : String

If you have more than 1 ProtoUser in your application, you'll need to distinguish the menu names.

def menus : List[Menu]

An alias for the sitemap property

def modSnippet (xhtml: NodeSeq, obj: ModelType, cleanup: (ModelType) ⇒ Unit): NodeSeq

Default snippet for modification.

def mutateUserOnEdit (user: TheUserType): TheUserType

If there's any mutation to do to the user on retrieval for editting, override this method and mutate the user.

def mutateUserOnSignup (user: TheUserType): TheUserType

If there's any mutation to do to the user on creation for signup, override this method and mutate the user.

def ne (arg0: AnyRef): Boolean

def niceName (inst: TheUserType): String

Get a nice name for the user

def niceNameWEmailLink (inst: TheUserType): Elem

Get an email link for the user

def notLoggedIn_? : Boolean

Inverted loggedIn_?

def notify (): Unit

def notifyAll (): Unit

def objFromIndexedParam : Box[ModelType]

Lame attempt at automatically getting an object from the HTTP parameters.

var onLogIn : List[(TheUserType) ⇒ Unit]

var onLogOut : List[(Box[TheUserType]) ⇒ Unit]

def passwordReset (id: String): NodeSeq

def passwordResetEmailSubject : String

def passwordResetMailBody (user: TheUserType, resetLink: String): Elem

lazy val passwordResetPath : List[String]

The computed path for the reset password screen

def passwordResetSuffix : String

The path suffix for the reset password screen

def passwordResetXhtml : Elem

def prependField (pf: FieldPF): Unit

def reload : ModelType

def resetPasswordMenuLoc : Box[Menu]

The menu item for resetting the password (make this "Empty" to disable)

def resetPasswordMenuLocParams : List[LocParam[Unit]]

The LocParams for the menu item for resetting the password.

val rootClass : java.lang.Class[_ >: ?0]

def runSafe [T] (f: ⇒ T): T

def runValidationList (toValidate: ModelType): List[FieldError]

Run the list of field validations, etc.

def safe_? : Boolean

def save (toSave: ModelType): Boolean

def save (): Boolean

def saveMe (): ModelType

Save the instance and return the instance

def saved_? (toSave: ModelType): Boolean

def saved_? : Boolean

def screenWrap : Box[Node]

What template are you going to wrap the various nodes in

def sendPasswordReset (email: String): Unit

Send password reset email to the user.

def sendValidationEmail (user: TheUserType): Unit

Send validation email to the user.

def shortName (inst: TheUserType): String

Get a nice name for the user

lazy val signUpPath : List[String]

The computed path for the sign up screen

def signUpSuffix : String

The path suffix for the sign up screen

def signup : NodeSeq

def signupFields : List[FieldPointerType]

The list of fields presented to the user at sign-up

object signupFunc extends RequestVar[Box[() ⇒ NodeSeq]]

def signupMailBody (user: TheUserType, validationLink: String): Elem

def signupMailSubject : String

def signupXhtml (user: TheUserType): Elem

lazy val sitemap : List[Menu]

def sitemapMutator : (SiteMap) ⇒ SiteMap

The SiteMap mutator function

def skipEmailValidation : Boolean

def snarfLastItem : String

def superUser_? : Boolean

Is there a user logged in and are they a superUser?

def suplementalJs (ob: Box[KeyObfuscator]): List[(String, JsExp)]

If the instance calculates any additional fields for JSON object, put the calculated fields here

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

def testLoggedIn (page: String): Boolean

lazy val testLogginIn : If

A Menu.

lazy val testSuperUser : If

A Menu.

def thePath (end: String): List[String]

Calculate the path given a suffix by prepending the basePath to the suffix

implicit def thisToMappee (in: Mapper[ModelType]): ModelType

def timeZoneField : Box[MappedTimeZone[ModelType]]

def toForm (toMap: ModelType): NodeSeq

def toForm (button: Box[String], redoSnippet: (NodeSeq) ⇒ NodeSeq, onSuccess: (ModelType) ⇒ Unit): NodeSeq

def toForm (button: Box[String], f: (ModelType) ⇒ Any): NodeSeq

Present the model as a form and execute the function on submission of the form

def toForm (button: Box[String], onSuccess: String): NodeSeq

Present the model as a form and execute the function on submission of the form

def toHtml (toMap: ModelType): NodeSeq

Present the model as a HTML using the same formatting as toForm

def toHtml : NodeSeq

Present the model as a HTML using the same formatting as toForm

def toString (): String

def toXml (what: ModelType): Elem

def toXml : Elem

implicit def typeToBridge (in: TheUserType): UserBridge

Convert an instance of TheUserType to the Bridge trait

def uidAttributeName : String

def unapply (key: Any): Option[ModelType]

def updateFromJSON_! (toUpdate: ModelType, json: JObject): ModelType

This method will update the instance from JSON.

def userFromStringId (id: String): Box[TheUserType]

Given a String representing the User ID, find the user

def userMenu : List[Node]

def userNameFieldString : String

How do we prompt the user for the username.

def userNameNotFoundString : String

The string that's generated when the user name is not found.

def validate (toValidate: ModelType): List[FieldError]

def validate : List[FieldError]

def validateSignup (user: TheUserType): List[FieldError]

Override this method to validate the user signup (eg by adding captcha verification)

def validateUser (id: String): NodeSeq

def validateUserMenuLoc : Box[Menu]

The menu item for validating a user (make this "Empty" to disable)

def validateUserMenuLocParams : List[LocParam[Unit]]

The LocParams for the menu item for validating a user.

lazy val validateUserPath : List[String]

The calculated path to the user validation screen

def validateUserSuffix : String

The path suffix for the validate user screen

def validation : List[(ModelType) ⇒ List[FieldError]]

If there are model-specific validations to perform, override this method and return an additional list of validations to perform

def viewSnippet (xhtml: NodeSeq): NodeSeq

Default view snippet.

def viewSnippetSetup : ModelType

Default setup behavior for the view snippet.

def wait (): Unit

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

def wait (arg0: Long): Unit

def whatToSet (toSave: ModelType): String

def wrapIt (in: NodeSeq): NodeSeq