ProtoAuthUserMeta

abstract def findByStringId(id: String): Box[UserType]

Given a String representing the User ID, find the user

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit lazy val _formats: Formats

lazy val allFormats: Formats

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

def asDBObject(inst: UserType): DBObject

def asDocument(inst: UserType): Document

final def asInstanceOf[T0]: T0

def asJObject(rec: UserType): JObject

def asJSON(inst: UserType): JsObj

def asJValue(rec: UserType): JValue

def asJsExp(inst: UserType): JsExp

def bulkDelete_!!(k: String, o: Any): Unit

def bulkDelete_!!(qry: DBObject): Unit

def clone(): AnyRef

def collectionName: String

def connectionIdentifier: ConnectionIdentifier

def copy(rec: UserType): UserType

def count(qry: JObject): Long

def count(qry: DBObject): Long

def count: Long

def countDistinct(key: String, query: DBObject): Long

def createIndex(keys: JObject, opts: JObject): Unit

def createIndex(keys: JObject, unique: Boolean): Unit

def createRecord: UserType

def createWithMutableField[FieldType](original: UserType, field: Field[FieldType, UserType], newValue: Box[FieldType]): UserType

def currentUser: Box[UserType]

def currentUserId: Box[String]

def delete(qry: JObject): Unit

def delete(k: String, v: Any): Unit

def delete(qry: DBObject): Unit

def delete_!(inst: UserType): Boolean

def dirty_?(inst: UserType): Boolean

def drop: Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def fieldDbValue(f: Field[_, UserType]): Box[Any]

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

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

def finalize(): Unit

def find(k: String, o: Any): Box[UserType]

def find(json: JObject): Box[UserType]

def find(id: Long): Box[UserType]

def find(id: Int): Box[UserType]

def find(s: String): Box[UserType]

def find(uid: UUID): Box[UserType]

def find(oid: ObjectId): Box[UserType]

def find(qry: DBObject): Box[UserType]

def findAll(ids: List[ObjectId]): List[UserType]

def findAll(k: String, o: Any, sort: JObject, opts: FindOption*): List[UserType]

def findAll(k: String, o: Any, opts: FindOption*): List[UserType]

def findAll(qry: JObject, sort: JObject, opts: FindOption*): List[UserType]

def findAll(qry: JObject, opts: FindOption*): List[UserType]

def findAll(qry: DBObject, sort: DBObject, opts: FindOption*): List[UserType]

def findAll(qry: DBObject, opts: FindOption*): List[UserType]

def findAll(qry: JObject, keys: JObject, sort: Option[JObject], opts: FindOption*): List[UserType]

def findAll(sort: Option[DBObject], opts: FindOption*)(f: (DBCollection) ⇒ DBCursor): List[UserType]

def findAll(qry: DBObject, keys: DBObject, sort: Option[DBObject], opts: FindOption*): List[UserType]

def findAll(qry: DBObject, sort: Option[DBObject], opts: FindOption*): List[UserType]

def findAll: List[UserType]

def findAllByList[T](ids: List[T]): List[UserType]

def findAny(a: Any): Box[UserType]

def fixCollectionName: String

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

var formTemplate: Box[NodeSeq]

def formats: Formats

def fromDBObject(dbo: DBObject): UserType

def fromDocument(doc: Document): UserType

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

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

def fromReq(r: Req): UserType

final def getClass(): Class[_]

def handleLoginToken(): Box[LiftResponse]

Handle a LoginToken.

def hasAnyRoles(roles: Seq[String]): Boolean

def hasPermission(permission: Permission): Boolean

def hasRole(role: String): Boolean

Current user has the given role

def hashCode(): Int

def insertAll(insts: List[UserType]): Unit

def insertAsync(inst: UserType): Future[Boolean]

def instantiateRecord: UserType

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

def isAuthenticated: Boolean

true if user logged in by supplying password.

final def isInstanceOf[T0]: Boolean

def isLoggedIn: Boolean

True when the user request var is defined.

def lacksPermission(permission: Permission): Boolean

def lacksRole(role: String): Boolean

def logUserIn(who: UserType, isAuthed: Boolean = false, isRemember: Boolean = false): Unit

def logUserOut(): Unit

Log the current user out

def metaFields(): List[Field[_, UserType]]

def mutable_?: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onLogIn: List[(UserType) ⇒ Unit]

def onLogOut: List[(Box[UserType]) ⇒ Unit]

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

def replaceOneAsync(inst: UserType, upsert: Boolean, concern: WriteConcern): Future[UserType]

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

def save(inst: UserType, db: DB, concern: WriteConcern): Boolean

def save(inst: UserType, concern: WriteConcern): Boolean

def save(inst: UserType): Boolean

def saveOp(inst: UserType)(f: ⇒ Unit): Boolean

def setFieldsFromDBObject(inst: UserType, dbo: DBObject): Unit

def setFieldsFromDocument(inst: UserType, doc: Document): Unit

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

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

def setFieldsFromRecord(inst: UserType, rec: UserType): Unit

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

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

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

def toForm(inst: UserType): NodeSeq

def toString(): String

def toXHtml(inst: UserType): NodeSeq

def update(inst: UserType): Unit

def update(obj: UserType, update: DBObject): Unit

def update(query: DBObject, update: DBObject): Unit

def update(qry: JObject, newbr: UserType, opts: UpdateOption*): Unit

def update(qry: JObject, newbr: UserType, db: DB, opts: UpdateOption*): Unit

def update(qry: JObject, newobj: JObject, opts: UpdateOption*): Unit

def update(qry: JObject, newobj: JObject, db: DB, opts: UpdateOption*): Unit

def update(qry: DBObject, newobj: DBObject, db: DB, opts: UpdateOption*): Unit

def updateMulti(query: DBObject, update: DBObject): Unit

def updateOp(inst: UserType)(f: ⇒ Unit): Unit

def upsert(query: DBObject, update: DBObject): Unit

def useColl[T](f: (DBCollection) ⇒ T): T

def useCollAsync[T](f: (MongoCollection[Document]) ⇒ T): T

def useDb[T](f: (DB) ⇒ T): T

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit