http_handlers/com.hexagonkt.http.handlers/HttpContext

HttpContext

data class HttpContext( val event: HttpCall, val predicate: (Context<HttpCall>) -> Boolean, val nextHandlers: List<Handler<HttpCall>> = emptyList(), val nextHandler: Int = 0, val exception: Exception? = null, val attributes: Map<*, *> = emptyMap<Any, Any>(), val handled: Boolean = false) : Context<HttpCall>

Constructors

HttpContext

constructor(context: Context<HttpCall>)

constructor( request: HttpRequestPort = HttpRequest(), response: HttpResponsePort = HttpResponse(), predicate: HttpPredicate = HttpPredicate(), attributes: Map<*, *> = emptyMap<Any, Any>())

constructor( event: HttpCall, predicate: (Context<HttpCall>) -> Boolean, nextHandlers: List<Handler<HttpCall>> = emptyList(), nextHandler: Int = 0, exception: Exception? = null, attributes: Map<*, *> = emptyMap<Any, Any>(), handled: Boolean = false)

Properties

val accept: List<ContentType>

attributes

open override val attributes: Map<*, *>

authorization

val authorization: Authorization?

certificate

val certificate: X509Certificate?

certificateChain

val certificateChain: List<X509Certificate>

event

open override val event: HttpCall

exception

open override val exception: Exception? = null

formParameters

val formParameters: FormParameters

handled

open override val handled: Boolean = false

host

val host: String

method

val method: HttpMethod

nextHandler

open override val nextHandler: Int = 0

nextHandlers

open override val nextHandlers: List<Handler<HttpCall>>

origin

val origin: String?

parts

val parts: List<HttpPart>

partsMap

val partsMap: Map<String, HttpPart>

path

val path: String

pathParameters

val pathParameters: Map<String, String>

port

val port: Int

predicate

open override val predicate: (Context<HttpCall>) -> Boolean

protocol

val protocol: HttpProtocol

queryParameters

val queryParameters: QueryParameters

referer

val referer: String?

request

val request: HttpRequestPort

response

val response: HttpResponsePort

status

val status: HttpStatus

url

val url: URL

userAgent

val userAgent: String?

Functions

accepted

fun accepted( onConnect: WsSession.() -> Unit = {}, onBinary: WsSession.(data: ByteArray) -> Unit = {}, onText: WsSession.(text: String) -> Unit = {}, onPing: WsSession.(data: ByteArray) -> Unit = {}, onPong: WsSession.(data: ByteArray) -> Unit = {}, onClose: WsSession.(status: Int, reason: String) -> Unit = { _, _ -> }): HttpContext

badRequest

fun badRequest( body: Any = response.body, headers: Headers = response.headers, contentType: ContentType? = response.contentType, cookies: List<Cookie> = response.cookies, attributes: Map<*, *> = this.attributes): HttpContext

created

fun created( body: Any = response.body, headers: Headers = response.headers, contentType: ContentType? = response.contentType, cookies: List<Cookie> = response.cookies, attributes: Map<*, *> = this.attributes): HttpContext

forbidden

fun forbidden( body: Any = response.body, headers: Headers = response.headers, contentType: ContentType? = response.contentType, cookies: List<Cookie> = response.cookies, attributes: Map<*, *> = this.attributes): HttpContext

found

fun found( location: String, headers: Headers = response.headers, cookies: List<Cookie> = response.cookies, attributes: Map<*, *> = this.attributes): HttpContext

internalServerError

fun internalServerError(exception: Exception, headers: Headers = response.headers, attributes: Map<*, *> = this.attributes): HttpContext

fun internalServerError( body: Any = response.body, headers: Headers = response.headers, contentType: ContentType? = response.contentType, cookies: List<Cookie> = response.cookies, attributes: Map<*, *> = this.attributes): HttpContext

open override fun next(): HttpContext

notFound

fun notFound( body: Any = response.body, headers: Headers = response.headers, contentType: ContentType? = response.contentType, cookies: List<Cookie> = response.cookies, attributes: Map<*, *> = this.attributes): HttpContext

fun ok( body: Any = response.body, headers: Headers = response.headers, contentType: ContentType? = response.contentType, cookies: List<Cookie> = response.cookies, attributes: Map<*, *> = this.attributes): HttpContext

receive

fun receive( body: Any = request.body, headers: Headers = request.headers, contentType: ContentType? = request.contentType, accept: List<ContentType> = request.accept, cookies: List<Cookie> = request.cookies, attributes: Map<*, *> = this.attributes): HttpContext

redirect

fun redirect( status: HttpStatus, location: String, headers: Headers = response.headers, cookies: List<Cookie> = response.cookies, attributes: Map<*, *> = this.attributes): HttpContext

send

fun send(request: HttpRequestPort, attributes: Map<*, *> = this.attributes): HttpContext

fun send(response: HttpResponsePort, attributes: Map<*, *> = this.attributes): HttpContext

fun send( status: HttpStatus = response.status, body: Any = response.body, headers: Headers = response.headers, contentType: ContentType? = response.contentType, cookies: List<Cookie> = response.cookies, attributes: Map<*, *> = this.attributes): HttpContext

serverError

fun serverError(status: HttpStatus, exception: Exception, headers: Headers = response.headers, attributes: Map<*, *> = this.attributes): HttpContext

sse

fun sse(body: Flow.Publisher<ServerEvent>): HttpContext

unauthorized

fun unauthorized( body: Any = response.body, headers: Headers = response.headers, contentType: ContentType? = response.contentType, cookies: List<Cookie> = response.cookies, attributes: Map<*, *> = this.attributes): HttpContext

with

open override fun with( event: HttpCall, predicate: (Context<HttpCall>) -> Boolean, nextHandlers: List<Handler<HttpCall>>, nextHandler: Int, exception: Exception?, attributes: Map<*, *>, handled: Boolean): Context<HttpCall>