MetaMegaProtoUser

abstract def findUserByUniqueId(id: String): Box[(MetaMegaProtoUser.this)#TheUserType]

Given a unique id, find the user

abstract def findUserByUserName(email: String): Box[(MetaMegaProtoUser.this)#TheUserType]

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

abstract def userFromStringId(id: String): Box[(MetaMegaProtoUser.this)#TheUserType]

Given a String representing the User ID, find the user

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

lazy val ItemList: List[(MetaMegaProtoUser.this)#MenuItem]

def actionsAfterSignup(theUser: (MetaMegaProtoUser.this)#TheUserType, func: () ⇒ Nothing): Nothing

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

Append a DispatchPF function to LiftRules.dispatch.

final def asInstanceOf[T0]: T0

def asJObject(rec: ModelType): JObject

Encode a record instance into a JObject

def asJSON(inst: ModelType): JsObj

Returns the JSON representation of inst record

def asJValue(rec: ModelType): JValue

Encode a record instance into a JValue

def asJsExp(inst: ModelType): JsExp

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

var autologinFunc: Box[() ⇒ Unit]

def basePath: List[String]

def bccEmail: Box[String]

implicit def buildFieldBridge(from: (MetaMegaProtoUser.this)#FieldPointerType): (MetaMegaProtoUser.this)#FieldPointerBridge

Based on a FieldPointer, build a FieldPointerBridge

def capturePreLoginState(): () ⇒ Unit

def changePassword: NodeSeq

def changePasswordMenuLoc: Box[Menu]

def changePasswordMenuLocParams: List[LocParam[Unit]]

lazy val changePasswordPath: List[String]

def changePasswordSubmitButton(name: String, func: () ⇒ Any): NodeSeq

def changePasswordSuffix: String

def changePasswordXhtml: Elem

def clone(): AnyRef

def computeFieldFromPointer(instance: (MetaMegaProtoUser.this)#TheUserType, pointer: (MetaMegaProtoUser.this)#FieldPointerType): Box[BaseField]

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

def connectionIdentifier: ConnectionIdentifier

def copy(rec: ModelType): ModelType

def createNewUserInstance(): (MetaMegaProtoUser.this)#TheUserType

Create a new instance of the User

def createRecord: ModelType

Creates a new record

def createUserMenuLoc: Box[Menu]

def createUserMenuLocParams: List[LocParam[Unit]]

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 applying the new value for the specific field

def currentUser: Box[(MetaMegaProtoUser.this)#TheUserType]

def currentUserId: Box[String]

def destroySessionOnLogin: Boolean

def dirty_?(inst: ModelType): Boolean

def doWithUser[T](u: Box[(MetaMegaProtoUser.this)#TheUserType])(f: ⇒ T): T

def edit: NodeSeq

def editFields: List[(MetaMegaProtoUser.this)#FieldPointerType]

The list of fields presented to the user for editing

lazy val editPath: List[String]

def editSubmitButton(name: String, func: () ⇒ Any): NodeSeq

def editSuffix: String

def editUserMenuLoc: Box[Menu]

def editUserMenuLocParams: List[LocParam[Unit]]

def editXhtml(user: (MetaMegaProtoUser.this)#TheUserType): Elem

def emailFrom: String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fieldByName(fieldName: String, inst: ModelType): Box[Field[_, ModelType]]

Get a field by the field name

def fieldOrder: List[Field[_, ModelType]]

Defines the order of the fields in this record

def fields(rec: ModelType): List[Field[_, ModelType]]

Obtain the fields for a particular 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 having 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 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: (MetaMegaProtoUser.this)#TheUserType, resetLink: String): List[MailBodyType]

def generateValidationEmailBodies(user: (MetaMegaProtoUser.this)#TheUserType, resetLink: String): List[MailBodyType]

final def getClass(): Class[_]

def globalUserLocParams: List[LocParam[Unit]]

def hashCode(): Int

def homePage: String

def instantiateRecord: ModelType

Make a new record instance.

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

final def isInstanceOf[T0]: Boolean

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

def logUserIdIn(id: String): Unit

def logUserIn(who: (MetaMegaProtoUser.this)#TheUserType): Unit

def logUserIn(who: (MetaMegaProtoUser.this)#TheUserType, postLogin: () ⇒ Nothing): Nothing

def logUserOut(): Unit

def loggedIn_?: Boolean

def login: NodeSeq

def loginFirst: If

def loginMenuLoc: Box[Menu]

def loginMenuLocParams: List[LocParam[Unit]]

def loginPageURL: String

lazy val loginPath: List[String]

def loginSubmitButton(name: String, func: () ⇒ Any): NodeSeq

def loginSuffix: String

def loginXhtml: Elem

def logout: Nothing

def logoutCurrentUser: Unit

def logoutMenuLoc: Box[Menu]

def logoutMenuLocParams: List[LocParam[Unit]]

lazy val logoutPath: List[String]

def logoutSuffix: String

def lostPassword: NodeSeq

def lostPasswordMenuLoc: Box[Menu]

def lostPasswordMenuLocParams: List[LocParam[Unit]]

lazy val lostPasswordPath: List[String]

def lostPasswordSubmitButton(name: String, func: () ⇒ Any): NodeSeq

def lostPasswordSuffix: String

def lostPasswordXhtml: Elem

def menuNameSuffix: String

def menus: List[Menu]

def metaFields(): List[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: (MetaMegaProtoUser.this)#TheUserType): (MetaMegaProtoUser.this)#TheUserType

def mutateUserOnSignup(user: (MetaMegaProtoUser.this)#TheUserType): (MetaMegaProtoUser.this)#TheUserType

final def ne(arg0: AnyRef): Boolean

def niceName(inst: (MetaMegaProtoUser.this)#TheUserType): String

def niceNameWEmailLink(inst: (MetaMegaProtoUser.this)#TheUserType): Elem

def notLoggedIn_?: Boolean

final def notify(): Unit

final def notifyAll(): Unit

var onLogIn: List[((MetaMegaProtoUser.this)#TheUserType) ⇒ Unit]

var onLogOut: List[(Box[(MetaMegaProtoUser.this)#TheUserType]) ⇒ Unit]

def passwordReset(id: String): NodeSeq

def passwordResetEmailSubject: String

def passwordResetMailBody(user: (MetaMegaProtoUser.this)#TheUserType, resetLink: String): Elem

lazy val passwordResetPath: List[String]

def passwordResetSuffix: String

def passwordResetXhtml: Elem

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

Prepend a DispatchPF function to LiftRules.dispatch.

def resetPasswordMenuLoc: Box[Menu]

def resetPasswordMenuLocParams: List[LocParam[Unit]]

def resetPasswordSubmitButton(name: String, func: () ⇒ Any): NodeSeq

val rootClass: Class[?0] forSome {type ?0 >: ?0, type ?0 <: MetaRecord[ModelType] with ModelType}

def screenWrap: Box[Node]

def sendPasswordReset(email: String): Unit

def sendValidationEmail(user: (MetaMegaProtoUser.this)#TheUserType): Unit

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 setFieldsFromRecord(inst: ModelType, rec: ModelType): Unit

Populate the fields of the record with values from an existing record

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

Populate the fields of the record with values from the request

def shortName(inst: (MetaMegaProtoUser.this)#TheUserType): String

lazy val signUpPath: List[String]

def signUpSuffix: String

def signup: NodeSeq

def signupFields: List[(MetaMegaProtoUser.this)#FieldPointerType]

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

def signupMailBody(user: (MetaMegaProtoUser.this)#TheUserType, validationLink: String): Elem

def signupMailSubject: String

def signupSubmitButton(name: String, func: () ⇒ Any): NodeSeq

def signupXhtml(user: (MetaMegaProtoUser.this)#TheUserType): Elem

lazy val sitemap: List[Menu]

def sitemapMutator: (SiteMap) ⇒ SiteMap

def skipEmailValidation: Boolean

def snarfLastItem: String

def standardSubmitButton(name: String, func: () ⇒ Any): Elem

def superUser_?: Boolean

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

def testLoggedIn(page: String): Boolean

lazy val testLogginIn: If

lazy val testSuperUser: If

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

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: (MetaMegaProtoUser.this)#TheUserType): (MetaMegaProtoUser.this)#UserBridge

Convert an instance of TheUserType to the Bridge trait

def userMenu: List[Node]

def userNameFieldString: String

def userNameNotFoundString: String

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

Validates the inst Record by calling validators for each field

def validateSignup(user: (MetaMegaProtoUser.this)#TheUserType): List[FieldError]

def validateUser(id: String): NodeSeq

def validateUserMenuLoc: Box[Menu]

def validateUserMenuLocParams: List[LocParam[Unit]]

lazy val validateUserPath: List[String]

def validateUserSuffix: String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def wrapIt(in: NodeSeq): NodeSeq