Safe Haskell	None
Language	Haskell98

Web.Spock.Action

Contents

Action types
Handling requests
Working with context
Sending responses
Middleware helpers
Basic HTTP-Auth

Synopsis

Action types

type ActionT = ActionCtxT () #

data ActionCtxT ctx m a #

Instances

MonadTrans (ActionCtxT ctx) #
Methods lift :: Monad m => m a -> ActionCtxT ctx m a #
Monad m => Monad (ActionCtxT ctx m) #
Methods (>>=) :: ActionCtxT ctx m a -> (a -> ActionCtxT ctx m b) -> ActionCtxT ctx m b # (>>) :: ActionCtxT ctx m a -> ActionCtxT ctx m b -> ActionCtxT ctx m b # return :: a -> ActionCtxT ctx m a # fail :: String -> ActionCtxT ctx m a #
Functor m => Functor (ActionCtxT ctx m) #
Methods fmap :: (a -> b) -> ActionCtxT ctx m a -> ActionCtxT ctx m b # (<$) :: a -> ActionCtxT ctx m b -> ActionCtxT ctx m a #
Monad m => Applicative (ActionCtxT ctx m) #
Methods pure :: a -> ActionCtxT ctx m a # (<>) :: ActionCtxT ctx m (a -> b) -> ActionCtxT ctx m a -> ActionCtxT ctx m b # (>) :: ActionCtxT ctx m a -> ActionCtxT ctx m b -> ActionCtxT ctx m b # (<*) :: ActionCtxT ctx m a -> ActionCtxT ctx m b -> ActionCtxT ctx m a #
Monad m => Alternative (ActionCtxT ctx m) #
Methods empty :: ActionCtxT ctx m a # (<\|>) :: ActionCtxT ctx m a -> ActionCtxT ctx m a -> ActionCtxT ctx m a # some :: ActionCtxT ctx m a -> ActionCtxT ctx m [a] # many :: ActionCtxT ctx m a -> ActionCtxT ctx m [a] #
MonadIO m => MonadIO (ActionCtxT ctx m) #
Methods liftIO :: IO a -> ActionCtxT ctx m a #

Handling requests

request :: MonadIO m => ActionCtxT ctx m Request #

Get the original Wai Request object

header :: MonadIO m => Text -> ActionCtxT ctx m (Maybe Text) #

Read a header

rawHeader :: MonadIO m => HeaderName -> ActionCtxT ctx m (Maybe ByteString) #

Read a header without converting it to text

cookies :: MonadIO m => ActionCtxT ctx m [(Text, Text)] #

Read all cookies. The cookie value will already be urldecoded.

cookie :: MonadIO m => Text -> ActionCtxT ctx m (Maybe Text) #

Read a cookie. The cookie value will already be urldecoded. Note that it is more efficient to use cookies if you need do access many cookies during a request handler.

reqMethod :: MonadIO m => ActionCtxT ctx m SpockMethod #

Returns the current request method, e.g. GET

preferredFormat :: MonadIO m => ActionCtxT ctx m ClientPreferredFormat #

Tries to dected the preferred format of the response using the Accept header

data ClientPreferredFormat #

Constructors

PrefJSON
PrefXML
PrefHTML
PrefText
PrefUnknown

Instances

Eq ClientPreferredFormat #
Methods (==) :: ClientPreferredFormat -> ClientPreferredFormat -> Bool # (/=) :: ClientPreferredFormat -> ClientPreferredFormat -> Bool #
Show ClientPreferredFormat #
Methods showsPrec :: Int -> ClientPreferredFormat -> ShowS # show :: ClientPreferredFormat -> String # showList :: [ClientPreferredFormat] -> ShowS #

body :: MonadIO m => ActionCtxT ctx m ByteString #

Get the raw request body

jsonBody :: (MonadIO m, FromJSON a) => ActionCtxT ctx m (Maybe a) #

Parse the request body as json

jsonBody' :: (MonadIO m, FromJSON a) => ActionCtxT ctx m a #

Parse the request body as json and fails with 400 status code on error

files :: MonadIO m => ActionCtxT ctx m (HashMap Text UploadedFile) #

Get uploaded files

data UploadedFile #

Constructors

UploadedFile
Fields uf_name :: !Text uf_contentType :: !Text uf_tempLocation :: !FilePath

Instances

Show UploadedFile #
Methods showsPrec :: Int -> UploadedFile -> ShowS # show :: UploadedFile -> String # showList :: [UploadedFile] -> ShowS #

params :: MonadIO m => ActionCtxT ctx m [(Text, Text)] #

Get all request (POST + GET) params

paramsGet :: MonadIO m => ActionCtxT ctx m [(Text, Text)] #

Get all request GET params

paramsPost :: MonadIO m => ActionCtxT ctx m [(Text, Text)] #

Get all request POST params

param :: (FromHttpApiData p, MonadIO m) => Text -> ActionCtxT ctx m (Maybe p) #

Read a request param. Spock looks POST variables first and then in GET variables

param' :: (FromHttpApiData p, MonadIO m) => Text -> ActionCtxT ctx m p #

Like param, but outputs an error when a param is missing

Working with context

getContext :: MonadIO m => ActionCtxT ctx m ctx #

Get the context of the current request

runInContext :: MonadIO m => ctx' -> ActionCtxT ctx' m a -> ActionCtxT ctx m a #

Run an Action in a different context

Sending responses

setStatus :: MonadIO m => Status -> ActionCtxT ctx m () #

Set a response status

setHeader :: MonadIO m => Text -> Text -> ActionCtxT ctx m () #

Set a response header. If the response header is allowed to occur multiple times (as in RFC 2616), it will be appended. Otherwise the previous value is overwritten. See setMultiHeader.

redirect :: MonadIO m => Text -> ActionCtxT ctx m a #

Redirect to a given url

jumpNext :: MonadIO m => ActionCtxT ctx m a #

Abort the current action and jump the next one matching the route

data CookieSettings #

Cookie settings

Constructors

CookieSettings
Fields cs_EOL :: CookieEOL cookie expiration setting, see `CookieEOL` cs_path :: Maybe ByteString a path for the cookie cs_domain :: Maybe ByteString a domain for the cookie. `Nothing` means no domain is set cs_HTTPOnly :: Bool whether the cookie should be set as HttpOnly cs_secure :: Bool whether the cookie should be marked secure (sent over HTTPS only)

defaultCookieSettings :: CookieSettings #

Default cookie settings, equals

CookieSettings
  { cs_EOL      = CookieValidForSession
  , cs_HTTPOnly = False
  , cs_secure   = False
  , cs_domain   = Nothing
  , cs_path     = Just "/"
  }

data CookieEOL #

Setting cookie expiration

Constructors

CookieValidUntil UTCTime	a point in time in UTC until the cookie is valid
CookieValidFor NominalDiffTime	a period (in seconds) for which the cookie is valid
CookieValidForSession	the cookie expires with the browser session
CookieValidForever	the cookie will have an expiration date in the far future

setCookie :: MonadIO m => Text -> Text -> CookieSettings -> ActionCtxT ctx m () #

Set a cookie. The cookie value will be urlencoded.

deleteCookie :: MonadIO m => Text -> ActionCtxT ctx m () #

Delete a cookie

bytes :: MonadIO m => ByteString -> ActionCtxT ctx m a #

Send a ByteString as response body. Provide your own Content-Type

lazyBytes :: MonadIO m => ByteString -> ActionCtxT ctx m a #

Send a lazy ByteString as response body. Provide your own Content-Type

setRawMultiHeader :: MonadIO m => MultiHeader -> ByteString -> ActionCtxT ctx m () #

Set a response header that can occur multiple times. (eg: Cache-Control)

data MultiHeader #

Constructors

MultiHeaderCacheControl
MultiHeaderConnection
MultiHeaderContentEncoding
MultiHeaderContentLanguage
MultiHeaderPragma
MultiHeaderProxyAuthenticate
MultiHeaderTrailer
MultiHeaderTransferEncoding
MultiHeaderUpgrade
MultiHeaderVia
MultiHeaderWarning
MultiHeaderWWWAuth
MultiHeaderSetCookie

Instances

Bounded MultiHeader #
Methods minBound :: MultiHeader # maxBound :: MultiHeader #
Enum MultiHeader #
Methods succ :: MultiHeader -> MultiHeader # pred :: MultiHeader -> MultiHeader # toEnum :: Int -> MultiHeader # fromEnum :: MultiHeader -> Int # enumFrom :: MultiHeader -> [MultiHeader] # enumFromThen :: MultiHeader -> MultiHeader -> [MultiHeader] # enumFromTo :: MultiHeader -> MultiHeader -> [MultiHeader] # enumFromThenTo :: MultiHeader -> MultiHeader -> MultiHeader -> [MultiHeader] #
Eq MultiHeader #
Methods (==) :: MultiHeader -> MultiHeader -> Bool # (/=) :: MultiHeader -> MultiHeader -> Bool #
Show MultiHeader #
Methods showsPrec :: Int -> MultiHeader -> ShowS # show :: MultiHeader -> String # showList :: [MultiHeader] -> ShowS #
Generic MultiHeader #
Associated Types type Rep MultiHeader :: * -> * # Methods from :: MultiHeader -> Rep MultiHeader x # to :: Rep MultiHeader x -> MultiHeader #
Hashable MultiHeader #
Methods hashWithSalt :: Int -> MultiHeader -> Int # hash :: MultiHeader -> Int #
type Rep MultiHeader #
type Rep MultiHeader = D1 (MetaData "MultiHeader" "Web.Spock.Internal.Wire" "Spock-core-0.12.0.0-7upjlujMQaNI3vh9W7F1wi" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "MultiHeaderCacheControl" PrefixI False) U1) ((:+:) (C1 (MetaCons "MultiHeaderConnection" PrefixI False) U1) (C1 (MetaCons "MultiHeaderContentEncoding" PrefixI False) U1))) ((:+:) (C1 (MetaCons "MultiHeaderContentLanguage" PrefixI False) U1) ((:+:) (C1 (MetaCons "MultiHeaderPragma" PrefixI False) U1) (C1 (MetaCons "MultiHeaderProxyAuthenticate" PrefixI False) U1)))) ((:+:) ((:+:) (C1 (MetaCons "MultiHeaderTrailer" PrefixI False) U1) ((:+:) (C1 (MetaCons "MultiHeaderTransferEncoding" PrefixI False) U1) (C1 (MetaCons "MultiHeaderUpgrade" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "MultiHeaderVia" PrefixI False) U1) (C1 (MetaCons "MultiHeaderWarning" PrefixI False) U1)) ((:+:) (C1 (MetaCons "MultiHeaderWWWAuth" PrefixI False) U1) (C1 (MetaCons "MultiHeaderSetCookie" PrefixI False) U1)))))

text :: MonadIO m => Text -> ActionCtxT ctx m a #

Send text as a response body. Content-Type will be "text/plain"

html :: MonadIO m => Text -> ActionCtxT ctx m a #

Send a text as response body. Content-Type will be "text/html"

file :: MonadIO m => Text -> FilePath -> ActionCtxT ctx m a #

Send a file as response

json :: (ToJSON a, MonadIO m) => a -> ActionCtxT ctx m b #

Send json as response. Content-Type will be "application/json"

stream :: MonadIO m => StreamingBody -> ActionCtxT ctx m a #

Use a StreamingBody to generate a response.

response :: MonadIO m => (Status -> ResponseHeaders -> Response) -> ActionCtxT ctx m a #

Use a custom Response generator as response body.

respondApp :: Monad m => Application -> ActionCtxT ctx m a #

Respond to the request by running an Application. This is usefull in combination with wildcard routes. This can not be used in combination with other request consuming combinators like jsonBody, body, paramsPost, ...

respondMiddleware :: Monad m => Middleware -> ActionCtxT ctx m a #

Respond to the request by running a Middleware. This is usefull in combination with wildcard routes. This can not be used in combination with other request consuming combinators like jsonBody, body, paramsPost, ...

Middleware helpers

middlewarePass :: MonadIO m => ActionCtxT ctx m a #

If the Spock application is used as a middleware, you can use this to pass request handling to the underlying application. If Spock is not uses as a middleware, or there is no underlying application this will result in 404 error.

modifyVault :: MonadIO m => (Vault -> Vault) -> ActionCtxT ctx m () #

Modify the vault (useful for sharing data between middleware and app)

queryVault :: MonadIO m => Key a -> ActionCtxT ctx m (Maybe a) #

Query the vault

Basic HTTP-Auth

requireBasicAuth :: MonadIO m => Text -> (Text -> Text -> ActionCtxT ctx m b) -> (b -> ActionCtxT ctx m a) -> ActionCtxT ctx m a #

Convenience Basic authentification provide a title for the prompt and a function to validate user and password. Usage example:

get ("auth" <//> var <//> var) $ \user pass ->
      let checker user' pass' =
              unless (user == user' && pass == pass') $
              do setStatus status401
                 text "err"
      in requireBasicAuth "Foo" checker $ \() -> text "ok"

withBasicAuthData :: MonadIO m => (Maybe (Text, Text) -> ActionCtxT ctx m a) -> ActionCtxT ctx m a #

"Lower level" basic authentification handeling. Does not set any headers that will promt browser users, only looks for an Authorization header in the request and breaks it into username and passwort component if present