MetaMegaProtoUser

abstract def getSingleton: KeyedMetaMapper[Long, ModelType]

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

final def !=(arg0: Any): Boolean

final def ##(): Int

final 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[(MetaMegaProtoUser.this)#MenuItem]

final def _dbTableNameLC: String

The table name, to lower case...

def actionsAfterSignup(theUser: (MetaMegaProtoUser.this)#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 addFormSnippet(html: NodeSeq): NodeSeq

Base add form 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 allFieldNames(): Seq[(String, SourceFieldMetadata)]

Get a list of all the fields

def allFields: Seq[BaseField]

def appendFieldToStrings(in: ModelType): String

def appendFieldTransform(transform: CssSel): Unit

def asHtml(toLine: ModelType): NodeSeq

def asHtml: NodeSeq

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

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

implicit def buildFieldBridge(from: (MetaMegaProtoUser.this)#FieldPointerType): (MetaMegaProtoUser.this)#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 changePasswordSubmitButton(name: String, func: () ⇒ Any = () => {}): NodeSeq

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 comparePrimaryKeys(other: ModelType): Boolean

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

lazy val doAllFieldNames: Seq[(String, SourceFieldMetadata)]

Get a list of all the fields

def doHtmlLine(toLine: ModelType): NodeSeq

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

Append a function to perform after the commit happens

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

There may be times when you want to be another user for some stack frames.

def edit: NodeSeq

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

The list of fields presented to the user for editing

def editFormSnippet(html: NodeSeq): NodeSeq

Base edit form snippet.

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

lazy val editPath: List[String]

The computed path for the edit screen

def editSnippetCallback(obj: ModelType): Unit

Default callback behavior of the edit snippet.

def editSnippetSetup: ModelType

Default setup behavior for the edit snippet.

def editSubmitButton(name: String, func: () ⇒ Any = () => {}): NodeSeq

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

val elemName: String

def emailFrom: String

def encodeAsJSON_!(toEncode: ModelType): JObject

This method will encode the instance as JSON.

final 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 fieldMapperTransforms(fieldHtml: (BaseOwnedMappedField[ModelType]) ⇒ NodeSeq, mappedObject: ModelType): Seq[CssSel]

A set of CssSels that can be used to bind this MetaMapper's fields.

Seq(
  ".name" #> fieldHtml(-name field-),
  ".date" #> fieldHtml(-date field-),
  ".description" #> fieldHtml(-description field-)
)

def fieldMapperTransforms(fieldTransform: (BaseOwnedMappedField[ModelType]) ⇒ NodeSeq): Seq[CssSel]

Given a function that takes a mapper field and returns a NodeSeq for the field, return, for this mapper instance, a set of CSS selector transforms that will transform a form for those fields into a fully-bound form that will interact with this instance.

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

lazy val fieldNamesAsMap: Map[String, SourceFieldMetadata]

Get a list of all the fields as a map

def fieldOrder: List[BaseOwnedMappedField[ModelType]]

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

def fieldTransforms: Seq[CssSel]

A list of CSS selector transforms that will help render the fields of this mapper object.

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 findSourceField(name: String): Box[SourceFieldInfo]

Given a name, look up the field

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

Given a unique id, find the user

def findUserByUserName(email: String): Box[(MetaMegaProtoUser.this)#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, MappedField[_, ModelType], NodeSeq) ⇒ Seq[T]): List[T]

flat map the fields titles and forms to generate a list

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

flat map the fields titles and forms to generate a list

def formFields(toMap: ModelType): List[MappedField[_, ModelType]]

Get the fields (in order) for displaying a form

def formFields: List[MappedField[_, ModelType]]

Get the fields (in order) for displaying a form

def formSnippet(html: NodeSeq, obj: ModelType, cleanup: (ModelType) ⇒ Unit): NodeSeq

Provides basic transformation of html to a form for the given obj.

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: (MetaMegaProtoUser.this)#TheUserType, resetLink: String): List[MailBodyType]

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

def generateValidationEmailBodies(user: (MetaMegaProtoUser.this)#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

final def getClass(): Class[_]

def globalUserLocParams: List[LocParam[Unit]]

If you want to include a LocParam (e.g.

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

final def isInstanceOf[T0]: Boolean

def localForm(user: (MetaMegaProtoUser.this)#TheUserType, ignorePassword: Boolean, fields: List[(MetaMegaProtoUser.this)#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: (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

A Menu.LocParam for testing if the user is logged in and if they're not, redirect them to the login page

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 loginSubmitButton(name: String, func: () ⇒ Any = () => {}): NodeSeq

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 lostPasswordSubmitButton(name: String, func: () ⇒ Any = () => {}): NodeSeq

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

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

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

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

final def ne(arg0: AnyRef): Boolean

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

Get a nice name for the user

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

Get an email link for the user

def notLoggedIn_?: Boolean

Inverted loggedIn_?

final def notify(): Unit

final def notifyAll(): Unit

def objFromIndexedParam: Box[ModelType]

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

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]

The computed path for the reset password screen

def passwordResetSuffix: String

The path suffix for the reset password screen

def passwordResetXhtml: Elem

def prependFieldTransform(transform: CssSel): 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.

def resetPasswordSubmitButton(name: String, func: () ⇒ Any = () => {}): NodeSeq

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

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

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

Run the list of field validations, etc.

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

Send validation email to the user.

def shortName(inst: (MetaMegaProtoUser.this)#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[(MetaMegaProtoUser.this)#FieldPointerType]

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

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

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

The SiteMap mutator function

def skipEmailValidation: Boolean

def snarfLastItem: String

def standardSubmitButton(name: String, func: () ⇒ Any = () => {}): Elem

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

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

def testLoggedIn(page: String): Boolean

lazy val testLogginIn: If

A Menu.LocParam to test if the user is logged in

lazy val testSuperUser: If

A Menu.LocParam to test if the user is a super user

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

Convert an instance of TheUserType to the Bridge trait

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[(MetaMegaProtoUser.this)#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.

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

def validate: List[FieldError]