Web.Respond.Request

contains various matching utilities

extracting the request body

getBodyLazy :: MonadRespond m => m ByteString

gets the body as a lazy ByteString using lazy IO (see lazyRequestBody)

getBodyStrict :: MonadRespond m => m ByteString

gets the body as a lazy ByteString using strict IO (see strictRequestBody)

extraction using FromBody

extractBodyLazy :: (ReportableError e, FromBody e a, MonadRespond m) => m (Either e a)

use a FromBody instance to parse the body. uses getBodyLazy to lazily load the body data.

extractBodyStrict :: (ReportableError e, FromBody e a, MonadRespond m) => m (Either e a)

uses a FromBody instance to parse the body. uses getBodyStrict to load the body strictly.

withRequiredBody :: (ReportableError e, FromBody e a, MonadRespond m) => (a -> m ResponseReceived) -> m ResponseReceived

extracts the body using extractBodyLazy. runs the inner action only if the body could be loaded and parseda using the FromBody instance; otherwise responds with the reportable error by calling handleBodyParseFailure.

withRequiredBody' :: (ReportableError e, FromBody e a, MonadRespond m) => (a -> m ResponseReceived) -> m ResponseReceived

extracts the body using extractBodyStrict. runs the inner action only if the body could be loaded and parseda using the FromBody instance; otherwise responds with the reportable error by calling handleBodyParseFailure.

authentication and authorization

authenticate :: (MonadRespond m, ReportableError e) => m (Either e a) -> (a -> m ResponseReceived) -> m ResponseReceived

authenticate uses the result of the authentication action (if it succssfully produced a result) to run the inner action function. otherwise, it uses handleAuthFailed.

reauthenticate :: (MonadRespond m, ReportableError e) => Maybe a -> m (Either e a) -> (a -> m ResponseReceived) -> m ResponseReceived

reauthenticate tries to use a prior authentication value to run the inner action; if it's not availalble, it falls back to authenticate to apply the auth action and run the inner action.

authorize :: (ReportableError e, MonadRespond m) => Maybe e -> m ResponseReceived -> m ResponseReceived

if given an error report value , respond immediately using handleDenied. otherwise, run the inner route.

authorizeBool :: (ReportableError e, MonadRespond m) => e -> Bool -> m ResponseReceived -> m ResponseReceived

if the bool is true, run the inner. otherwise, handleDenied the report.

authorizeE :: (ReportableError e, MonadRespond m) => Either e a -> (a -> m ResponseReceived) -> m ResponseReceived

authorize using an Either; if it's Left, fail using handleDenied on the contained ReportableError. if it's right, run the inner action using the contained value,

content negotiation

routeAccept

Arguments

:: MonadRespond m

=> m a

default action - do this if nothing matches

-> [(MediaType, m a)]

actions to perform for each accepted media type

-> m a

chosen action

selects action by accept header

checkAccepts :: MonadRespond m => [MediaType] -> m ResponseReceived -> m ResponseReceived

defends the inner routes by first checking the Accept header and failing if it cannot accept any media type in the list