ProtoUser

implicit abstract def buildFieldBridge(from: FieldPointerType): FieldPointerBridge

Based on a FieldPointer, build a FieldPointerBridge

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

Given an instance of TheCrudType and FieldPointerType, convert that to an actual instance of a BaseField on the instance of TheCrudType

abstract def createNewUserInstance(): TheUserType

Create a new instance of the User

abstract def editFields: List[FieldPointerType]

The list of fields presented to the user for editing

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

Given a unique id, find the user

abstract def findUserByUserName(username: String): Box[TheUserType]

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

abstract def signupFields: List[FieldPointerType]

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

implicit abstract def typeToBridge(in: TheUserType): UserBridge

Convert an instance of TheUserType to the Bridge trait

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

Given a String representing the User ID, find the user

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

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

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

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

final def asInstanceOf[T0]: T0

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

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 currentUser: Box[TheUserType]

def currentUserId: Box[String]

def destroySessionOnLogin: Boolean

By default, destroy the session on login.

def doWithUser[T](u: Box[TheUserType])(f: ⇒ T): T

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

def edit: NodeSeq

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

lazy val editPath: List[String]

The computed path for the edit screen

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: TheUserType): Elem

def emailFrom: String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

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

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

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

Generate the mail bodies to send with the valdiation link.

final def getClass(): 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

final 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 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 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: TheUserType): 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: TheUserType): 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: 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_?

final def notify(): Unit

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

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

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

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

def signupMailSubject: String

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

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

def superUser_?: Boolean

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

final 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 toString(): String

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def wrapIt(in: NodeSeq): NodeSeq