SkinnyResourceServletWithId

abstract def createForm: MapValidator

Input form for creation

abstract def createFormStrongParameters: Seq[(String, ParamType)]

Strong parameter definitions for creation form

abstract def model: SkinnyModel[Id, _]

SkinnyModel for this resource.

abstract def resourceName: String

Resource name in the singular.

abstract def resourcesName: String

Resource name in the plural.

abstract def updateForm: MapValidator

Input form for modification

abstract def updateFormStrongParameters: Seq[(String, ParamType)]

Strong parameter definitions for modification form

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object WithRendering extends controller.feature.SkinnyControllerCommonBase.RenderingRequired with Product with Serializable

object WithoutRendering extends controller.feature.SkinnyControllerCommonBase.RenderingRequired with Product with Serializable

def acceptHeader(implicit request: HttpServletRequest): List[String]

def acceptedFormats(accepted: Symbol*): Boolean

val actionDefinitions: ArrayBuffer[ActionDefinition]

Note: Same action method name should be registered several times.

def addActionDefinition(actionDef: ActionDefinition): Unit

Adds action definition

def addErrorFilter(handler: ErrorHandler): Unit

Adds error handler which doesn't return result to SkinnyController.

def addMimeMapping(mime: String, extension: String): Unit

def addParam(name: String, value: Any)(implicit ctx: SkinnyContext = context): Unit

Add param to params in the request scope.

def addRoute(method: HttpMethod, transformers: Seq[RouteTransformer], action: ⇒ Any): Route

def after(transformers: RouteTransformer*)(fun: ⇒ Any): Unit

def afterAction(only: Seq[Symbol] = Nil, except: Seq[Symbol] = Nil)(action: ⇒ Any): Unit

Registers afterAction to this controller.

def afterFilter(only: Seq[Symbol] = Nil, except: Seq[Symbol] = Nil)(action: ⇒ Any): Unit

If you prefer #afterFilter than #afterAction, keep going!

implicit val anyToBoolean: micro.implicits.TypeConverter[Any, Boolean]

implicit val anyToByte: micro.implicits.TypeConverter[Any, Byte]

implicit val anyToDouble: micro.implicits.TypeConverter[Any, Double]

implicit val anyToFloat: micro.implicits.TypeConverter[Any, Float]

implicit val anyToInt: micro.implicits.TypeConverter[Any, Int]

implicit val anyToLong: micro.implicits.TypeConverter[Any, Long]

implicit val anyToShort: micro.implicits.TypeConverter[Any, Short]

implicit val anyToString: micro.implicits.TypeConverter[Any, String]

final def asInstanceOf[T0]: T0

def asJValue[T](obj: T)(implicit writer: Writer[T]): JValue

def before(transformers: RouteTransformer*)(fun: ⇒ Any): Unit

def beforeAction(only: Seq[Symbol] = Nil, except: Seq[Symbol] = Nil)(action: ⇒ Any): Unit

Registers beforeAction to this controller.

def beforeFilter(only: Seq[Symbol] = Nil, except: Seq[Symbol] = Nil)(action: ⇒ Any): Unit

If you prefer #beforeFilter than #beforeAction, keep going!

implicit def booleanBlock2RouteMatcher(block: ⇒ Boolean): RouteMatcher

lazy val charset: Option[String]

def clone(): AnyRef

def compact(value: JValue): String

var config: ThinServletBaseConfig

implicit def configWrapper(config: ThinServletBaseConfig): Config { def initParameters: skinny.micro.context.InitParameters }

def contentType(implicit ctx: SkinnyContext): String

def contentTypeInferrer: ContentTypeInferrer

def contentType_=(contentType: String)(implicit ctx: SkinnyContext): Unit

def context: SkinnyContext

def contextPath: String

implicit def convertParamsToStrongParameters(params: micro.Params): StrongParameters

implicit def convertRouteToRichRoute(route: Route)(implicit controller: SkinnyControllerCommonBase): RichRoute

implicit def cookieOptions(implicit ctx: SkinnyContext): CookieOptions

def cookies(implicit ctx: SkinnyContext): SweetCookies

def countResources(): Long

def createApiAction: Any

val createApiUrl: Route

def createI18n()(implicit locale: Locale = ...): I18n

Creates skinny.I18n instance for current locale.

def createParams: Params

Params for creation.

def createRenderContext(out: PrintWriter)(implicit ctx: SkinnyContext): SkinnyScalateRenderContext

Creates a RenderContext instance for Skinny app.

def createResource()(implicit format: Format = Format.HTML): Any

Creates new resource.

def createSkinnyScalateRenderContext(ctx: SkinnyContext): SkinnyScalateRenderContext

def createTemplateEngine(config: ThinServletBaseConfig): TemplateEngine

Creates TemplateEngine instance for Skinny app.

val createUrl: Route

val createWithSlashUrl: Route

def csrfKey: String

Overrides Skinny Micro's default key name.

def csrfToken(implicit context: SkinnyContext): String

def currentActionName(implicit cxt: SkinnyContext = context): Option[Symbol]

Returns action name for this request.

def currentErrorHandler: ErrorHandler

def currentLocale(implicit ctx: SkinnyContext): Option[Locale]

Returns current locale for this request.

def debugLoggingParameters(form: MapValidator, id: Option[Id] = None): Unit

Outputs debug logging for passed parameters.

def debugLoggingPermittedParameters(parameters: PermittedStrongParameters, id: Option[Id] = None): Unit

Outputs debug logging for permitted parameters.

def defaultAcceptedFormats: List[Symbol]

val defaultCharacterEncoding: String

def defaultFormat: Symbol

def defaultIndexName: String

def defaultLayoutPath: Option[String]

def defaultLocale: Option[Locale]

Returns default locale.

def defaultObjectMapper: ObjectMapper

implicit def defaultStringToSeq[T](implicit elementConverter: micro.implicits.TypeConverter[String, T], mf: Manifest[T]): micro.implicits.TypeConverter[String, Seq[T]]

def defaultTemplateFormat: String

def defaultTemplatePath: List[String]

Overrides to make the template path simpler.

def delete(transformers: RouteTransformer*)(action: ⇒ Any): Route

def deleteAction: Any

def deleteApiAction: Any

def destroy(): Unit

val destroyApiUrl: Route

def destroyResource(id: Id)(implicit format: Format = Format.HTML): Any

Destroys the specified resource.

val destroyUrl: Route

def detectTooManyErrorFilterRegistrationAsAnErrorAtSkinnyMicroBase: Boolean

def doCreateAndReturnId(parameters: PermittedStrongParameters): Id

Executes resource creation.

def doDelete(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

def doDestroy(id: Id): Int

Executes deletion of the specified single resource.

def doGet(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

def doHead(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

var doNotFound: Action

def doOptions(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

def doPost(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

def doPut(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

def doTrace(arg0: HttpServletRequest, arg1: HttpServletResponse): Unit

def doUpdate(id: Id, parameters: PermittedStrongParameters): Int

Executes modification for the specified resource.

def editResource(id: Id)(implicit format: Format = Format.HTML): Any

Shows input form for modification.

val editUrl: Route

def enablePagination: Boolean

implicit def enrichRequest(request: HttpServletRequest): RichRequest

implicit def enrichResponse(response: HttpServletResponse): RichResponse

implicit def enrichServletContext(servletContext: javax.servlet.ServletContext): RichServletContext

implicit def enrichSession(session: HttpSession): RichHttpServletSession

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(handler: ErrorHandler): Unit

def errorMessages(implicit ctx: SkinnyContext = context): Seq[String]

Returns errorMessages in the RequestScope.

def executeRoutes(request: HttpServletRequest, response: HttpServletResponse): Unit

implicit def executionContext: ExecutionContext

def finalize(): Unit

def findResource(id: Id): Option[_]

def findResources(): List[_]

def findResources(pageSize: Int, pageNo: Int): List[_]

def findTemplate(path: String, extensionSet: Set[String]): Option[String]

def flash(key: String)(implicit ctx: SkinnyContext): Any

def flash(implicit ctx: SkinnyContext): FlashMap

def flashMapSetSession(f: FlashMap)(implicit ctx: SkinnyContext): Unit

def formMultiParams(implicit ctx: SkinnyContext): micro.MultiParams

def formParams(implicit ctx: SkinnyContext): micro.Params

def format(implicit ctx: SkinnyContext): String

def formatForMimeTypes(mimeTypes: String*): Option[String]

def format_=(formatValue: String)(implicit ctx: SkinnyContext): Unit

val formats: Map[String, String]

def fromJSONString[A](json: String, underscoreKeys: Boolean, asIs: Boolean)(implicit mf: Manifest[A]): Try[A]

def fromJSONStringAsIs[A](json: String)(implicit mf: Manifest[A]): Try[A]

def fromJSONStringToJValue(json: String, underscoreKeys: Boolean, asIs: Boolean): Try[JValue]

def fromJValue[T](json: JValue)(implicit reader: Reader[T]): T

def fullUrl(path: String, params: Iterable[(String, Any)], includeContextPath: Boolean, includeServletPath: Boolean, withSessionId: Boolean)(implicit ctx: SkinnyContext): String

def generateWelcomePageIfAbsent(path: String)(implicit format: Format = Format.HTML): Unit

Generates a sample page for absent page.

def get(transformers: RouteTransformer*)(action: ⇒ Any): Route

final def getClass(): Class[_]

def getFromRequestScope[A](key: String)(implicit ctx: SkinnyContext = context): Option[A]

Fetches value from request scope.

def getInitParameter(arg0: String): String

def getInitParameterNames(): Enumeration[String]

def getLastModified(arg0: HttpServletRequest): Long

def getServletConfig(): ServletConfig

def getServletContext(): javax.servlet.ServletContext

def getServletInfo(): String

def getServletName(): String

def halt(result: ActionResult): Nothing

def halt[T](status: Integer, body: T, headers: Map[String, String], reason: String)(implicit arg0: Manifest[T]): Nothing

def haltWithBody[A](httpStatus: Int)(implicit ctx: SkinnyContext, format: Format = Format.HTML): A

Halts with body which responds to the specified format.

def handle(req: HttpServletRequest, res: HttpServletResponse): Unit

def handleForgery(): Unit

Overrides to skip execution when the current request matches excluded patterns.

def handleForgeryIfDetected(): Nothing

Handles when CSRF is detected.

def hashCode(): Int

def head(transformers: RouteTransformer*)(action: ⇒ Any): Route

def idName: String

Id field name.

def idParamName: String

Id parameter name.

def indexApiAction: Any

val indexApiUrl: Route

val indexUrl: Route

val indexWithSlashUrl: Route

def inferFromFormats: ContentTypeInferrer

def infoTimeLoggingEnabled: Boolean

def init(config: ServletConfig): Unit

def init(): Unit

def initParameter(name: String): Option[String]

def initialize(config: ThinServletBaseConfig): Unit

def initializeRequestScopeAttributes(implicit ctx: SkinnyContext = context): Any

def invoke(matchedRoute: MatchedRoute): Option[Any]

def isAsyncExecutable(result: Any): Boolean

def isDevelopment(): Boolean

def isForged: Boolean

final def isInstanceOf[T0]: Boolean

def isProduction(): Boolean

def isScalateErrorPageEnabled: Boolean

To deal with exceptions.

def isStaging(): Boolean

def isTest(): Boolean

def itemName: String

Item variable name in view templates.

def itemsName: String

Items variable name in view templates.

def jade(path: String, attributes: (String, Any)*)(implicit ctx: SkinnyContext): String

implicit val jsonFormats: Formats

def keyAndErrorMessages(implicit ctx: SkinnyContext = context): Map[String, Seq[String]]

Returns keyAndErrorMessages in the RequestScope.

def layout(path: String)(implicit ctx: SkinnyContext): ScalateTemplateEngineFeature

Replaces layout template for this action.

def layoutTemplate(path: String, attributes: (String, Any)*)(implicit ctx: SkinnyContext): String

def layoutTemplateAs(ext: Set[String])(path: String, attributes: (String, Any)*)(implicit ctx: SkinnyContext): String

def log(arg0: String, arg1: Throwable): Unit

def log(arg0: String): Unit

def logger: Logger

def loggerName: String

implicit def lowestPriorityAny2T[T](implicit arg0: Manifest[T]): micro.implicits.TypeConverter[Any, T]

def maxDurationToAwaitAsyncFilters: Duration

def messageResourceName: String

Resource name in messages.conf

def methodNotAllowed(f: (Set[HttpMethod]) ⇒ Any): Unit

val mimeTypes: Map[String, String]

def mount(ctx: javax.servlet.ServletContext): Unit

def multiParams(key: String)(implicit ctx: SkinnyContext): Seq[String]

def multiParams(implicit ctx: SkinnyContext): micro.MultiParams

def mustache(path: String, attributes: (String, Any)*)(implicit ctx: SkinnyContext): String

final def ne(arg0: AnyRef): Boolean

def newResource()(implicit format: Format = Format.HTML): Any

Shows input form for creation.

val newUrl: Route

final def normalizedResourcesBasePath: String

Normalized base path.

def notFound(fun: ⇒ Any): Unit

final def notify(): Unit

final def notifyAll(): Unit

def options(transformers: RouteTransformer*)(action: ⇒ Any): Route

def pageNoParamName: String

def pageSize: Int

def pageSizeParamName: String

def params(implicit ctx: SkinnyContext): micro.Params

def params(key: Symbol)(implicit ctx: SkinnyContext): String

def params(key: String)(implicit ctx: SkinnyContext): String

def pass(): Nothing

def patch(transformers: RouteTransformer*)(action: ⇒ Any): Route

implicit def pathPatternParser2RouteMatcher(pattern: PathPattern): RouteMatcher

def post(transformers: RouteTransformer*)(action: ⇒ Any): Route

def preferredScalateExtension: String

The Scalate template type that is searched for first.

def prefixForJSONVulnerabilityProtection: String

def prepareCsrfToken(): Any

def protectFromForgery(only: Seq[Symbol] = Nil, except: Seq[Symbol] = Nil): Unit

Declarative activation of CSRF protection.

def put(transformers: RouteTransformer*)(action: ⇒ Any): Route

def queryMultiParams(implicit ctx: SkinnyContext): micro.MultiParams

def queryParams(implicit ctx: SkinnyContext): micro.Params

def redirect(uri: String)(implicit ctx: SkinnyContext): ActionResult

def redirect301(location: String, headers: Map[String, String])(implicit ctx: SkinnyContext): ActionResult

def redirect302(location: String, headers: Map[String, String])(implicit ctx: SkinnyContext): ActionResult

def redirect303(location: String, headers: Map[String, String])(implicit ctx: SkinnyContext): ActionResult

implicit def regex2RouteMatcher(regex: Regex): RouteMatcher

def relativeUrl(path: String, params: Iterable[(String, Any)], includeContextPath: Boolean, includeServletPath: Boolean)(implicit ctx: SkinnyContext): String

def removeRoute(method: String, route: Route): Unit

def removeRoute(method: HttpMethod, route: Route): Unit

def render(path: String)(implicit ctx: SkinnyContext, format: Format = Format.HTML): String

Renders body with template.

def renderResponse(actionResult: Any)(implicit ctx: SkinnyContext): Unit

def renderResponseBody(actionResult: Any)(implicit ctx: SkinnyContext): Unit

def renderUncaughtException(e: Throwable)(implicit ctx: SkinnyContext): Unit

def renderWithFormat(entity: Any)(implicit format: micro.Format = Format.HTML): String

Renders body which responds to the specified format (JSON, XML) if possible.

def renderWithTemplate(path: String)(implicit ctx: SkinnyContext, format: Format = Format.HTML): String

Renders body with template.

def request(implicit ctx: SkinnyContext): HttpServletRequest

def requestFormat(implicit ctx: SkinnyContext): String

def requestPath(implicit ctx: SkinnyContext): String

def requestScope(keyAndValues: Seq[(String, Any)])(implicit ctx: SkinnyContext): RequestScopeFeature

Set attributes to request scope.

def requestScope(keyAndValue: (String, Any))(implicit ctx: SkinnyContext): RequestScopeFeature

Set attribute to request scope.

def requestScope(implicit ctx: SkinnyContext = context): Map[String, Any]

Returns whole request scope attributes.

def resourceNotFound()(implicit ctx: SkinnyContext): Any

def resourcesBasePath: String

Base path.

def resourcesBasePathPrefix: String

Base path prefix.

def respondTo: Seq[micro.Format]

def response(implicit ctx: SkinnyContext): HttpServletResponse

def responseAsJSON(entity: Any, charset: Option[String], prettify: Boolean, underscoreKeys: Boolean)(implicit ctx: SkinnyContext): String

def routeBasePath(implicit ctx: SkinnyContext): String

def routeForShowApi: Route

lazy val routes: RouteRegistry

implicit def safe[S, T](f: (S) ⇒ T): micro.implicits.TypeConverter[S, T]

implicit def safeOption[S, T](f: (S) ⇒ Option[T]): micro.implicits.TypeConverter[S, T]

def scalateExtensions: List[String]

Scalate extension names.

def scalateRenderContextNumberFormat: DecimalFormat

Creates a DecimalFormat instance to be use by default.

def scaml(path: String, attributes: (String, Any)*)(implicit ctx: SkinnyContext): String

def sensitiveParameterNames: Seq[String]

Returns registered sensitive parameter names.

implicit def seqHead[T](implicit elementConverter: micro.implicits.TypeConverter[String, T], mf: Manifest[T]): micro.implicits.TypeConverter[Seq[String], T]

implicit def seqToSeq[T](implicit elementConverter: micro.implicits.TypeConverter[String, T], mf: Manifest[T]): micro.implicits.TypeConverter[Seq[String], Seq[T]]

def serveStaticResource()(implicit ctx: SkinnyContext): Option[Any]

def serverAuthority(implicit ctx: SkinnyContext): String

def serverHost(implicit ctx: SkinnyContext): String

def serverPort(implicit ctx: SkinnyContext): Int

def service(request: HttpServletRequest, response: HttpServletResponse): Unit

def service(arg0: ServletRequest, arg1: ServletResponse): Unit

implicit def servletContext: javax.servlet.ServletContext

def session(key: Symbol)(implicit ctx: SkinnyContext): Any

def session(key: String)(implicit ctx: SkinnyContext): Any

implicit def session(implicit ctx: SkinnyContext): HttpSession

def sessionLocaleKey: String

Session key to store current locale string.

def sessionOption(implicit ctx: SkinnyContext): Option[HttpSession]

def set(keyAndValues: Seq[(String, Any)])(implicit ctx: SkinnyContext): RequestScopeFeature

Set attributes to request scope.

def set(keyAndValue: (String, Any))(implicit ctx: SkinnyContext): RequestScopeFeature

Set attribute to request scope.

def setAsParams(model: Any)(implicit ctx: SkinnyContext = context): Unit

Set params which is generated from a model object using Java reflection APIs.

def setContentTypeFromSkinnyApiResourceExtParam: Unit

Set Content-Type response header which is suitable for specified extension.

def setContentTypeIfAbsent()(implicit format: micro.Format = Format.HTML): Unit

Set Content-Type for the format if absent.

def setCreateCompletionFlash(): Unit

Set notice flash message for successful completion of creation.

def setCurrentLocale(locale: String)(implicit ctx: SkinnyContext): Unit

Set current locale.

def setDestroyCompletionFlash(): FlashMap

Set notice flash message for successful completion of deletion.

def setI18n(implicit ctx: SkinnyContext = context): RequestScopeFeature

Set {{skinny.I18n}} object for the current request to request scope.

def setMultiparams[S](matchedRoute: Option[MatchedRoute], originalParams: micro.MultiParams)(implicit ctx: SkinnyContext): Unit

def setParams(implicit ctx: SkinnyContext = context): Unit

Set params to request scope.

def setParamsToRequestScope(implicit ctx: SkinnyContext = context): Unit

Set params to request scope.

def setRequestCharacterEncodingAsDefaultIfAbsent(request: HttpServletRequest): Unit

def setUpdateCompletionFlash(): FlashMap

Set notice flash message for successful completion of modification.

def showApiAction: Any

val showApiUrl: Route

def showResource(id: Id)(implicit format: Format = Format.HTML): Any

Show single resource.

def showResources()(implicit format: Format = Format.HTML): Any

Shows a list of resource.

val showUrl: Route

def shutdown(): Unit

implicit def skinnyContext(implicit ctx: javax.servlet.ServletContext): SkinnyContext

implicit val skinnyController: SkinnyControllerCommonBase

Pass this controller instance implicitly because skinny.routing.implicits.RoutesAsImplicits expects skinny.controller.SkinnyControllerBase.

def skinnyEnv: Option[String]

lazy val skinnyErrorFilters: TrieMap[RenderingRequired, Seq[ErrorHandler]]

Registered error handlers.

implicit val skinnyMicroParamsIdTypeConverter: TypeConverter[String, Id]

to enable params.getAs[Id]("id")

implicit def skinnyValidatorSafe[S, T](f: (S) ⇒ T): ParamValueTypeConverter[S, T]

implicit def skinnyValidatorSafeOption[S, T](f: (S) ⇒ Option[T]): ParamValueTypeConverter[S, T]

implicit def skinnyValidatorSeqHead[T](implicit elementConverter: ParamValueTypeConverter[String, T], mf: Manifest[T]): ParamValueTypeConverter[Seq[String], T]

implicit def skinnyValidatorSeqToSeq[T](implicit elementConverter: ParamValueTypeConverter[String, T], mf: Manifest[T]): ParamValueTypeConverter[Seq[String], Seq[T]]

implicit val skinnyValidatorStringToBoolean: ParamValueTypeConverter[String, Boolean]

implicit val skinnyValidatorStringToByte: ParamValueTypeConverter[String, Byte]

def skinnyValidatorStringToDate(format: ⇒ String): ParamValueTypeConverter[String, Date]