DeadboltActions

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val Accepted: Status

val BadGateway: Status

val BadRequest: Status

def Composite[A](handler: DeadboltHandler = handlers(), constraint: Constraint[A])(bodyParser: BodyParser[A] = parse.anyContent)(block: (AuthenticatedRequest[A]) ⇒ Future[Result]): Action[A]

Allows access if the composite constraint resolves to true..

val Conflict: Status

val Created: Status

def Dynamic[A](name: String, meta: Option[Any] = None, handler: DeadboltHandler = handlers())(bodyParser: BodyParser[A] = parse.anyContent)(block: (AuthenticatedRequest[A]) ⇒ Future[Result]): Action[A]

Apply a dynamic constraint to a controller action.

val EntityTooLarge: Status

val ExpectationFailed: Status

val FailedDependency: Status

val Forbidden: Status

def Found(url: String): Result

val GatewayTimeout: Status

val Gone: Status

val HttpVersionNotSupported: Status

val InsufficientStorage: Status

val InternalServerError: Status

val Locked: Status

val MethodNotAllowed: Status

def MovedPermanently(url: String): Result

val MultiStatus: Status

val NoContent: Result

val NonAuthoritativeInformation: Status

val NotAcceptable: Status

val NotFound: Status

val NotImplemented: Status

val NotModified: Result

val Ok: Status

val PartialContent: Status

def Pattern[A](value: String, patternType: PatternType = PatternType.EQUALITY, meta: Option[Any] = None, handler: DeadboltHandler = handlers(), invert: Boolean = false)(bodyParser: BodyParser[A] = parse.anyContent)(block: (AuthenticatedRequest[A]) ⇒ Future[Result]): Action[A]

val PaymentRequired: Status

def PermanentRedirect(url: String): Result

val PreconditionFailed: Status

def Redirect(call: Call, status: Int): Result

def Redirect(call: Call): Result

def Redirect(url: String, queryString: Map[String, Seq[String]], status: Int): Result

def Redirect(url: String, status: Int): Result

val RequestTimeout: Status

val ResetContent: Result

def Restrict[A](roleGroups: RoleGroups, handler: DeadboltHandler = handlers())(bodyParser: BodyParser[A] = parse.anyContent)(block: (AuthenticatedRequest[A]) ⇒ Future[Result]): Action[A]

Restrict access to an action to users that have all the specified roles within a given group.

def Restrict[A](roleNames: RoleGroup, handler: DeadboltHandler)(bodyParser: BodyParser[A])(block: (AuthenticatedRequest[A]) ⇒ Future[Result]): Action[A]

Restrict access to an action to users that have all the specified roles.

def SeeOther(url: String): Result

val ServiceUnavailable: Status

def Status(code: Int): Status

def SubjectNotPresent[A](handler: DeadboltHandler = handlers())(bodyParser: BodyParser[A] = parse.anyContent)(block: (AuthenticatedRequest[A]) ⇒ Future[Result]): Action[A]

Denies access to the action if there is a subject present.

def SubjectPresent[A](handler: DeadboltHandler = handlers())(bodyParser: BodyParser[A] = parse.anyContent)(block: (AuthenticatedRequest[A]) ⇒ Future[Result]): Action[A]

Allows access to the action if there is a subject present.

def TemporaryRedirect(url: String): Result

val TooManyRequests: Status

val Unauthorized: Status

val UnprocessableEntity: Status

val UnsupportedMediaType: Status

val UriTooLong: Status

def WithAuthRequest[A](handler: DeadboltHandler = handlers())(bodyParser: BodyParser[A] = parse.anyContent)(block: (AuthenticatedRequest[A]) ⇒ Future[Result]): Action[A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val ec: ExecutionContext

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def execute[A](handler: DeadboltHandler, bodyParser: BodyParser[A], block: (AuthenticatedRequest[A]) ⇒ Future[Result]): Action[A]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

object parse

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val TooManyRequest: Status