MetaMegaProtoUser

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 userFromStringId (id: String): Box[TheUserType]

Given a String representing the User ID, find the user

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 actionsAfterSignup (theUser: TheUserType, func: () ⇒ Nothing): Nothing

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

def appendDispatch (func: PartialFunction[Req, (ModelType) ⇒ Box[LiftResponse]]): RulesSeq[PartialFunction[Req, () ⇒ Box[LiftResponse]]]

Append a DispatchPF function to LiftRules.

def asInstanceOf [T0] : T0

def asJSON (inst: ModelType): JsObj

Returns the JSON representation of inst record

def asJValue (rec: ModelType): JObject

Encode a record instance into a JValue

def asJsExp (inst: ModelType): JsExp

Retuns the JSON representation of inst record, converts asJValue to JsObj

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]

implicit def buildFieldBridge (from: FieldPointerType): FieldPointerBridge

Based on a FieldPointer, build a FieldPointerBridge

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 clone (): AnyRef

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

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

def createNewUserInstance (): TheUserType

Create a new instance of the User

def createRecord : ModelType

Creates a new record

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 createWithMutableField [FieldType] (original: ModelType, field: Field[FieldType, ModelType], newValue: Box[FieldType]): ModelType

Creates a new record setting the value of the fields from the original object but apply the new value for the specific field

def currentUser : Box[TheUserType]

def currentUserId : Box[String]

def destroySessionOnLogin : Boolean

By default, destroy the session on login.

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 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

def emailFrom : String

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def fieldByName (fieldName: String, inst: ModelType): Box[net.liftweb.record.Field[_, ModelType]]

Get a field by the field name

def fieldOrder : List[net.liftweb.record.Field[_, ModelType]]

Defined the order of the fields in this record

def fields (rec: ModelType): List[net.liftweb.record.Field[_, ModelType]]

Obtain the fields for a particlar Record or subclass instance by passing the instance itself.

def finalize (): Unit

def foreachCallback (inst: ModelType, f: (LifecycleCallbacks) ⇒ Any): Unit

var formTemplate : Box[NodeSeq]

Set this to use your own form template when rendering a Record to a form.

<lift:field_label name="firstName"/> - the label for firstName field will be rendered here
<lift:field name="firstName"/> - the firstName field will be rendered here (typically an input field)
<lift:field_msg name="firstName"/> - the  will be rendered here hafing the id given by
                                            uniqueFieldId of the firstName field.


Example.

Having:

class MyRecord extends Record[MyRecord] {

	def meta = MyRecordMeta

	object firstName extends StringField(this, "John")

}

object MyRecordMeta extends MyRecord with MetaRecord[MyRecord] {
 override def mutable_? = false
}

...

val rec = MyRecordMeta.createRecord.firstName("McLoud")

val template =
<div>
	<div>
		<div><lift:field_label name="firstName"/></div>
		<div><lift:field name="firstName"/></div>
		<div><lift:field_msg name="firstName"/></div>
	</div>
</div>

MyRecordMeta.formTemplate = Full(template)
rec.toForm((r:MyRecord) => println(r));

def fromJSON (json: String): Box[ModelType]

Create a record with fields populated with values from the JSON construct

def fromJValue (jvalue: JValue): Box[ModelType]

Create a record by decoding a JValue which must be a JObject

def fromJsonString (json: String): Box[ModelType]

Create a record with fields populated with values from the JSON construct

def fromReq (r: Req): ModelType

Create a record with fields populated with values from the request

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 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 instantiateRecord : ModelType

Make a new record instance.

def introspect (rec: ModelType, methods: Array[Method])(f: (Method, net.liftweb.record.Field[_, ModelType]) ⇒ Any): Unit

def isInstanceOf [T0] : Boolean

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

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 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 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 metaFields (): List[net.liftweb.record.Field[_, ModelType]]

Renamed from fields() due to a clash with fields() in Record.

def mutable_? : Boolean

Specifies if this Record is mutable or not

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

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 prependDispatch (func: PartialFunction[Req, (ModelType) ⇒ Box[LiftResponse]]): RulesSeq[PartialFunction[Req, () ⇒ Box[LiftResponse]]]

Prepend a DispatchPF function to LiftRules.

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 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 setFieldsFromJSON (inst: ModelType, json: String): Box[Unit]

Populate the fields of the record instance with values from the JSON construct

def setFieldsFromJValue (rec: ModelType, jvalue: JValue): Box[Unit]

Attempt to decode a JValue, which must be a JObject, into a record instance

def setFieldsFromJsonString (inst: ModelType, json: String): Box[Unit]

Set from a Json String using the lift-json parser

def setFieldsFromReq (inst: ModelType, req: Req): Unit

Populate the fields of the record with values from the request

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 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

def toForm (inst: ModelType, template: NodeSeq): NodeSeq

Returns the XHTML representation of inst Record.

def toForm (inst: ModelType): NodeSeq

Returns the XHTML representation of inst Record.

def toString (): String

def toXHtml (inst: ModelType): NodeSeq

Returns the HTML representation of inst Record.

implicit def typeToBridge (in: TheUserType): UserBridge

Convert an instance of TheUserType to the Bridge trait

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 (inst: ModelType): List[FieldError]

Validates the inst Record by calling validators for each field

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 wait (): Unit

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

def wait (arg0: Long): Unit

def wrapIt (in: NodeSeq): NodeSeq