MetaLDAPProtoUser

abstract def getSingleton: KeyedMetaMapper[Long, ModelType]

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

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

final def _dbTableNameLC: String

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

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

def addSnippet(xhtml: NodeSeq): NodeSeq

def addSnippetCallback(obj: ModelType): Unit

def addSnippetSetup: ModelType

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: (MetaLDAPProtoUser.this)#FieldPF): Unit

def appendFieldToStrings(in: ModelType): String

def asHtml(toLine: ModelType): NodeSeq

def asHtml: NodeSeq

final def asInstanceOf[T0]: T0

def asJs(actual: ModelType): JsExp

def asJs: JsExp

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

def asSafeJs(f: KeyObfuscator): JsExp

def asValid: Box[ModelType]

var autologinFunc: Box[() ⇒ Unit]

def basePath: List[String]

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: (MetaLDAPProtoUser.this)#FieldPointerType): (MetaLDAPProtoUser.this)#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]])

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

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

def capturePreLoginState(): () ⇒ Unit

def changePassword: NodeSeq

def changePasswordMenuLoc: Box[Menu]

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

def changePasswordMenuLocParams: List[LocParam[Unit]]

lazy val changePasswordPath: List[String]

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

def changePasswordSuffix: String

def changePasswordXhtml: Elem

def checkNames: Unit

def clean_?(toCheck: ModelType): Boolean

def clone(): AnyRef

val columnNamesForInsert: String

def columnPrimaryKey_?(name: String): Boolean

val columnQueriesForInsert: String

def commonNameAttributeName: String

def comparePrimaryKeys(other: ModelType): Boolean

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

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

def createUserMenuLoc: Box[Menu]

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

def createUserMenuLocParams: List[LocParam[Unit]]

def crudSnippets: SnippetPF

def crudSnippets_?: Boolean

def currentUser: Box[(MetaLDAPProtoUser.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

def dbSelectDBConnectionForFind: PartialFunction[Long, ConnectionIdentifier]

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

def dbTableName: String

def db_can_delete_?: Boolean

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

def delete_!(toDelete: ModelType): Boolean

def delete_!: Boolean

def destroySessionOnLogin: Boolean

def dirty_?(toTest: ModelType): Boolean

def dirty_?: Boolean

var displayFieldAsLineElement: (NodeSeq) ⇒ NodeSeq

var displayNameToHeaderElement: (String) ⇒ NodeSeq

def doHtmlLine(toLine: ModelType): NodeSeq

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

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

def edit: NodeSeq

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

lazy val editPath: List[String]

def editSnippet(xhtml: NodeSeq): NodeSeq

def editSnippetCallback(obj: ModelType): Unit

def editSnippetSetup: ModelType

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

def editSuffix: String

def editUserMenuLoc: Box[Menu]

def editUserMenuLocParams: List[LocParam[Unit]]

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

val elemName: String

def emailFrom: String

def encodeAsJSON_!(toEncode: ModelType): JObject

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

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

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

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

def fieldMapperPF(transform: (BaseOwnedMappedField[ModelType]) ⇒ NodeSeq): (MetaLDAPProtoUser.this)#FieldPF

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

def fieldOrder: List[(MetaLDAPProtoUser.this)#FieldPointerType]

def fieldPF: (MetaLDAPProtoUser.this)#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]

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]

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

def findOrCreate(key: Any): ModelType

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

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

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

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

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

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

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

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

var formatFormElement: (NodeSeq, NodeSeq) ⇒ NodeSeq

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

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

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

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

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

final def getClass(): Class[_]

def globalUserLocParams: List[LocParam[Unit]]

def hashCode(): Int

def homePage: String

def htmlHeaders: NodeSeq

def htmlLine: NodeSeq

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

final def isInstanceOf[T0]: Boolean

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

def ldapUserSearch: String

User search sentence

def ldapVendor: LDAPVendor

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

def localeField: Box[MappedLocale[ModelType]]

def logUserIdIn(id: String): Unit

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

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

def logUserOut(): Unit

def loggedIn_?: Boolean

def login: NodeSeq

def loginErrorMessage: String

Error messages

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]

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

def lostPasswordMenuLocParams: List[LocParam[Unit]]

lazy val lostPasswordPath: List[String]

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

def lostPasswordSuffix: String

def lostPasswordXhtml: Elem

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

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

lazy val mappedFields: Seq[BaseMappedField]

lazy val mappedFieldsForModel: List[MappedField[_, ModelType]]

def menuNameSuffix: String

def menus: List[Menu]

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

def mutateUserOnEdit(user: (MetaLDAPProtoUser.this)#TheUserType): (MetaLDAPProtoUser.this)#TheUserType

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

final def ne(arg0: AnyRef): Boolean

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

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

def notLoggedIn_?: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def objFromIndexedParam: Box[ModelType]

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

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

def passwordReset(id: String): NodeSeq

def passwordResetEmailSubject: String

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

lazy val passwordResetPath: List[String]

def passwordResetSuffix: String

def passwordResetXhtml: Elem

def prependField(pf: (MetaLDAPProtoUser.this)#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]]

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]

final def safe_?: Boolean

def save(toSave: ModelType): Boolean

def save(): Boolean

def saveMe(): ModelType

def saved_?(toSave: ModelType): Boolean

def saved_?: Boolean

def screenWrap: Box[Node]

def sendPasswordReset(email: String): Unit

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

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

lazy val signUpPath: List[String]

def signUpSuffix: String

def signup: NodeSeq

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

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

def signupMailSubject: String

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

def signupXhtml(user: (MetaLDAPProtoUser.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

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

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]

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

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

def toHtml(toMap: ModelType): NodeSeq

def toHtml: NodeSeq

def toString(): String

def toXml(what: ModelType): Elem

def toXml: Elem

implicit def typeToBridge(in: (MetaLDAPProtoUser.this)#TheUserType): (MetaLDAPProtoUser.this)#UserBridge

def uidAttributeName: String

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

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

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

def userMenu: List[Node]

def userNameFieldString: String

def userNameNotFoundString: String

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

def validate: List[FieldError]

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

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

lazy val validateUserPath: List[String]

def validateUserSuffix: String

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

def viewSnippet(xhtml: NodeSeq): NodeSeq

def viewSnippetSetup: ModelType

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def whatToSet(toSave: ModelType): String

def wrapIt(in: NodeSeq): NodeSeq