Gets the first matching named input parameter as a String

Searches the QUERY_STRING followed by the Request body.

This function assumes the underlying octets are UTF-8 encoded.

Example:

handler :: ServerPart Response
handler =
     do foo <- look "foo"
        ok $ toResponse $ "foo = " ++ foo

see also: looks, lookBS, and lookBSs

Gets all matches for the named input parameter as Strings

Searches the QUERY_STRING followed by the Request body.

This function assumes the underlying octets are UTF-8 encoded.

see also: look and lookBSs

Gets the first matching named input parameter as a lazy Text

Searches the QUERY_STRING followed by the Request body.

This function assumes the underlying octets are UTF-8 encoded.

see also: lookTexts, look, looks, lookBS, and lookBSs

Gets the first matching named input parameter as a strict Text

Searches the QUERY_STRING followed by the Request body.

This function assumes the underlying octets are UTF-8 encoded.

see also: lookTexts, look, looks, lookBS, and lookBSs

Gets all matches for the named input parameter as lazy Texts

Searches the QUERY_STRING followed by the Request body.

This function assumes the underlying octets are UTF-8 encoded.

see also: lookText, looks and lookBSs

Gets all matches for the named input parameter as strict Texts

Searches the QUERY_STRING followed by the Request body.

This function assumes the underlying octets are UTF-8 encoded.

see also: lookText', looks and lookBSs

Gets the first matching named input parameter as a lazy ByteString

Searches the QUERY_STRING followed by the Request body.

see also: lookBSs

Gets all matches for the named input parameter as lazy ByteStrings

Searches the QUERY_STRING followed by the Request body.

see also: lookBS

Gets the first matching named input parameter and decodes it using Read

Searches the QUERY_STRING followed by the Request body.

This function assumes the underlying octets are UTF-8 encoded.

see also: lookReads

Gets all matches for the named input parameter and decodes them using Read

Searches the QUERY_STRING followed by the Request body.

This function assumes the underlying octets are UTF-8 encoded.

see also: lookReads

Gets the first matching named file

Files can only appear in the request body. Additionally, the form must set enctype="multipart/form-data".

This function returns a tuple consisting of:

1. The temporary location of the uploaded file
2. The local filename supplied by the browser
3. The content-type supplied by the browser

If the user does not supply a file in the html form input field, the behaviour will depend upon the browser. Most browsers will send a 0-length file with an empty file name, so checking that (2) is not empty is usually sufficient to ensure the field has been filled.

NOTE: You must move the file from the temporary location before the Response is sent. The temporary files are automatically removed after the Response is sent.

gets all the input parameters, and converts them to a String

The results will contain the QUERY_STRING followed by the Request body.

This function assumes the underlying octets are UTF-8 encoded.

see also: lookPairsBS

gets all the input parameters

The results will contain the QUERY_STRING followed by the Request body.

see also: lookPairs

Gets the named cookie the cookie name is case insensitive

gets the named cookie as a string

gets the named cookie as the requested Read type

Gets the first matching named input parameter

Searches the QUERY_STRING followed by the Request body.

see also: lookInputs

Gets all matches for the named input parameter

Searches the QUERY_STRING followed by the Request body.

see also: lookInput

limit the scope to the Request body

handler :: ServerPart Response
handler =
    do foo <- body $ look "foo"
       ok $ toResponse $ "foo = " ++ foo

limit the scope to the QUERY_STRING

handler :: ServerPart Response
handler =
    do foo <- queryString $ look "foo"
       ok $ toResponse $ "foo = " ++ foo

limit the scope to Inputs which produce a ByteString (aka, not a file)

convert or validate a value

This is similar to fmap except that the function can fail by returning Left and an error message. The error will be propagated by calling rqDataError.

This function is useful for a number of things including:

1. Parsing a String into another type
2. Checking that a value meets some requirements (for example, that is an Int between 1 and 10).

Example usage at:

http://happstack.com/docs/crashcourse/RqData.html#rqdatacheckrq

like checkRq but the check function can be monadic

use fromReqURI to convert a String to a value of type a

look "key" `checkRq` (readRq "key")

use with checkRq

use read to convert a String to a value of type a

look "key" `checkRq` (unsafeReadRq "key")

use with checkRq

NOTE: This function is marked unsafe because some Read instances are vulnerable to attacks that attempt to create an out of memory condition. For example:

read "1e10000000000000" :: Integer

see also: readRq

The body of a Request is not received or decoded unless this function is invoked.

It is an error to try to use the look functions for a Request with out first calling this function.

It is ok to call decodeBody at the beginning of every request:

main = simpleHTTP nullConf $
          do decodeBody (defaultBodyPolicy "/tmp/" 4096 4096 4096)
             handlers

You can achieve finer granularity quotas by calling decodeBody with different values in different handlers.

Only the first call to decodeBody will have any effect. Calling it a second time, even with different quota values, will do nothing.

see defaultBodyPolicy

create a BodyPolicy for use with decodeBody

An applicative functor and monad for looking up key/value pairs in the QUERY_STRING, Request body, and cookies.

transform the result of 'RqData a'.

This is similar to fmap except it also allows you to modify the Errors not just a.

a list of errors

run RqData in a ServerMonad.

Example: a simple GET or POST variable based authentication guard. It handles the request with errorHandler if authentication fails.

 data AuthCredentials = AuthCredentials { username :: String,  password :: String }

 isValid :: AuthCredentials -> Bool
 isValid = const True

 myRqData :: RqData AuthCredentials
 myRqData = do
    username <- look "username"
    password <- look "password"
    return (AuthCredentials username password)

 checkAuth :: (String -> ServerPart Response) -> ServerPart Response
 checkAuth errorHandler = do
    d <- getDataFn myRqData
    case d of
        (Left e) -> errorHandler (unlines e)
        (Right a) | isValid a -> mzero
        (Right a) | otherwise -> errorHandler "invalid"

NOTE: you must call decodeBody prior to calling this function if the request method is POST, PUT, PATCH, etc.

similar to getDataFn, except it calls a sub-handler on success or mzero on failure.

NOTE: you must call decodeBody prior to calling this function if the request method is POST, PUT, PATCH, etc.

Used by withData and getData. Make your preferred data type an instance of FromData to use those functions.

A variant of getDataFn that uses FromData to chose your RqData for you. The example from getData becomes:

 data AuthCredentials = AuthCredentials { username :: String,  password :: String }

 isValid :: AuthCredentials -> Bool
 isValid = const True

 myRqData :: RqData AuthCredentials
 myRqData = do
    username <- look "username"
    password <- look "password"
    return (AuthCredentials username password)

 instance FromData AuthCredentials where
    fromData = myRqData

 checkAuth :: (String -> ServerPart Response) -> ServerPart Response
 checkAuth errorHandler = do
    d <- getData
    case d of
        (Left e) -> errorHandler (unlines e)
        (Right a) | isValid a -> mzero
        (Right a) | otherwise -> errorHandler "invalid"

NOTE: you must call decodeBody prior to calling this function if the request method is POST, PUT, PATCH, etc.

similar to getData except it calls a subhandler on success or mzero on failure.

NOTE: you must call decodeBody prior to calling this function if the request method is POST, PUT, PATCH, etc.

the environment used to lookup query parameters. It consists of the triple: (query string inputs, body inputs, cookie inputs)

A class for monads which contain a RqEnv