{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE OverloadedStrings  #-}
{-# LANGUAGE RecordWildCards    #-}
module Servant.Server.Internal.ServerError where

import           Control.Exception
                 (Exception)
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy  as LBS
import           Data.Typeable
                 (Typeable)
import qualified Network.HTTP.Types    as HTTP
import           Network.Wai
                 (Response, responseLBS)

data ServerError = ServerError
    { ServerError -> Int
errHTTPCode     :: Int
    , ServerError -> String
errReasonPhrase :: String
    , ServerError -> ByteString
errBody         :: LBS.ByteString
    , ServerError -> [Header]
errHeaders      :: [HTTP.Header]
    }
  deriving (Int -> ServerError -> ShowS
[ServerError] -> ShowS
ServerError -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ServerError] -> ShowS
$cshowList :: [ServerError] -> ShowS
show :: ServerError -> String
$cshow :: ServerError -> String
showsPrec :: Int -> ServerError -> ShowS
$cshowsPrec :: Int -> ServerError -> ShowS
Show, ServerError -> ServerError -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ServerError -> ServerError -> Bool
$c/= :: ServerError -> ServerError -> Bool
== :: ServerError -> ServerError -> Bool
$c== :: ServerError -> ServerError -> Bool
Eq, ReadPrec [ServerError]
ReadPrec ServerError
Int -> ReadS ServerError
ReadS [ServerError]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ServerError]
$creadListPrec :: ReadPrec [ServerError]
readPrec :: ReadPrec ServerError
$creadPrec :: ReadPrec ServerError
readList :: ReadS [ServerError]
$creadList :: ReadS [ServerError]
readsPrec :: Int -> ReadS ServerError
$creadsPrec :: Int -> ReadS ServerError
Read, Typeable)

instance Exception ServerError

responseServerError :: ServerError -> Response
responseServerError :: ServerError -> Response
responseServerError ServerError{Int
String
[Header]
ByteString
errHeaders :: [Header]
errBody :: ByteString
errReasonPhrase :: String
errHTTPCode :: Int
errHeaders :: ServerError -> [Header]
errBody :: ServerError -> ByteString
errReasonPhrase :: ServerError -> String
errHTTPCode :: ServerError -> Int
..} = Status -> [Header] -> ByteString -> Response
responseLBS Status
status [Header]
errHeaders ByteString
errBody
  where
    status :: Status
status = Int -> ByteString -> Status
HTTP.mkStatus Int
errHTTPCode (String -> ByteString
BS.pack String
errReasonPhrase)

-- | 'err300' Multiple Choices
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err300 { errBody = "I can't choose." }
--
err300 :: ServerError
err300 :: ServerError
err300 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
300
                    , errReasonPhrase :: String
errReasonPhrase = String
"Multiple Choices"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err301' Moved Permanently
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError err301
--
err301 :: ServerError
err301 :: ServerError
err301 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
301
                    , errReasonPhrase :: String
errReasonPhrase = String
"Moved Permanently"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err302' Found
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError err302
--
err302 :: ServerError
err302 :: ServerError
err302 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
302
                    , errReasonPhrase :: String
errReasonPhrase = String
"Found"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err303' See Other
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError err303
--
err303 :: ServerError
err303 :: ServerError
err303 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
303
                    , errReasonPhrase :: String
errReasonPhrase = String
"See Other"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err304' Not Modified
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError err304
--
err304 :: ServerError
err304 :: ServerError
err304 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
304
                    , errReasonPhrase :: String
errReasonPhrase = String
"Not Modified"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err305' Use Proxy
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError err305
--
err305 :: ServerError
err305 :: ServerError
err305 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
305
                    , errReasonPhrase :: String
errReasonPhrase = String
"Use Proxy"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err307' Temporary Redirect
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError err307
--
err307 :: ServerError
err307 :: ServerError
err307 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
307
                    , errReasonPhrase :: String
errReasonPhrase = String
"Temporary Redirect"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err400' Bad Request
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err400 { errBody = "Your request makes no sense to me." }
--
err400 :: ServerError
err400 :: ServerError
err400 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
400
                    , errReasonPhrase :: String
errReasonPhrase = String
"Bad Request"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err401' Unauthorized
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err401 { errBody = "Your credentials are invalid." }
--
err401 :: ServerError
err401 :: ServerError
err401 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
401
                    , errReasonPhrase :: String
errReasonPhrase = String
"Unauthorized"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err402' Payment Required
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err402 { errBody = "You have 0 credits. Please give me $$$." }
--
err402 :: ServerError
err402 :: ServerError
err402 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
402
                    , errReasonPhrase :: String
errReasonPhrase = String
"Payment Required"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err403' Forbidden
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err403 { errBody = "Please login first." }
--
err403 :: ServerError
err403 :: ServerError
err403 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
403
                    , errReasonPhrase :: String
errReasonPhrase = String
"Forbidden"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err404' Not Found
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err404 { errBody = "Are you lost?" }
--
err404 :: ServerError
err404 :: ServerError
err404 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
404
                    , errReasonPhrase :: String
errReasonPhrase = String
"Not Found"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err405' Method Not Allowed
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err405 { errBody = "Your account privileges does not allow for this.  Please pay $$$." }
--
err405 :: ServerError
err405 :: ServerError
err405 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
405
                    , errReasonPhrase :: String
errReasonPhrase = String
"Method Not Allowed"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err406' Not Acceptable
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError err406
--
err406 :: ServerError
err406 :: ServerError
err406 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
406
                    , errReasonPhrase :: String
errReasonPhrase = String
"Not Acceptable"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err407' Proxy Authentication Required
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError err407
--
err407 :: ServerError
err407 :: ServerError
err407 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
407
                    , errReasonPhrase :: String
errReasonPhrase = String
"Proxy Authentication Required"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err409' Conflict
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err409 { errBody = "Transaction conflicts with 59879cb56c7c159231eeacdd503d755f7e835f74" }
--
err409 :: ServerError
err409 :: ServerError
err409 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
409
                    , errReasonPhrase :: String
errReasonPhrase = String
"Conflict"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err410' Gone
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err410 { errBody = "I know it was here at some point, but.. I blame bad luck." }
--
err410 :: ServerError
err410 :: ServerError
err410 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
410
                    , errReasonPhrase :: String
errReasonPhrase = String
"Gone"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err411' Length Required
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError err411
--
err411 :: ServerError
err411 :: ServerError
err411 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
411
                    , errReasonPhrase :: String
errReasonPhrase = String
"Length Required"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err412' Precondition Failed
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err412 { errBody = "Precondition fail: x < 42 && y > 57" }
--
err412 :: ServerError
err412 :: ServerError
err412 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
412
                    , errReasonPhrase :: String
errReasonPhrase = String
"Precondition Failed"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err413' Request Entity Too Large
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err413 { errBody = "Request exceeded 64k." }
--
err413 :: ServerError
err413 :: ServerError
err413 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
413
                    , errReasonPhrase :: String
errReasonPhrase = String
"Request Entity Too Large"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err414' Request-URI Too Large
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err414 { errBody = "Maximum length is 64." }
--
err414 :: ServerError
err414 :: ServerError
err414 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
414
                    , errReasonPhrase :: String
errReasonPhrase = String
"Request-URI Too Large"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err415' Unsupported Media Type
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err415 { errBody = "Supported media types:  gif, png" }
--
err415 :: ServerError
err415 :: ServerError
err415 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
415
                    , errReasonPhrase :: String
errReasonPhrase = String
"Unsupported Media Type"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err416' Request range not satisfiable
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err416 { errBody = "Valid range is [0, 424242]." }
--
err416 :: ServerError
err416 :: ServerError
err416 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
416
                    , errReasonPhrase :: String
errReasonPhrase = String
"Request range not satisfiable"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err417' Expectation Failed
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err417 { errBody = "I found a quux in the request.  This isn't going to work." }
--
err417 :: ServerError
err417 :: ServerError
err417 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
417
                    , errReasonPhrase :: String
errReasonPhrase = String
"Expectation Failed"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err418' Expectation Failed
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err418 { errBody = "Apologies, this is not a webserver but a teapot." }
--
err418 :: ServerError
err418 :: ServerError
err418 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
418
                    , errReasonPhrase :: String
errReasonPhrase = String
"I'm a teapot"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err422' Unprocessable Entity
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err422 { errBody = "I understood your request, but can't process it." }
--
err422 :: ServerError
err422 :: ServerError
err422 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
422
                    , errReasonPhrase :: String
errReasonPhrase = String
"Unprocessable Entity"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err500' Internal Server Error
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err500 { errBody = "Exception in module A.B.C:55.  Have a great day!" }
--
err500 :: ServerError
err500 :: ServerError
err500 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
500
                    , errReasonPhrase :: String
errReasonPhrase = String
"Internal Server Error"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err501' Not Implemented
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err501 { errBody = "/v1/foo is not supported with quux in the request." }
--
err501 :: ServerError
err501 :: ServerError
err501 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
501
                    , errReasonPhrase :: String
errReasonPhrase = String
"Not Implemented"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err502' Bad Gateway
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err502 { errBody = "Tried gateway foo, bar, and baz.  None responded." }
--
err502 :: ServerError
err502 :: ServerError
err502 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
502
                    , errReasonPhrase :: String
errReasonPhrase = String
"Bad Gateway"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err503' Service Unavailable
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err503 { errBody = "We're rewriting in PHP." }
--
err503 :: ServerError
err503 :: ServerError
err503 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
503
                    , errReasonPhrase :: String
errReasonPhrase = String
"Service Unavailable"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err504' Gateway Time-out
--
-- Example:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err504 { errBody = "Backend foobar did not respond in 5 seconds." }
--
err504 :: ServerError
err504 :: ServerError
err504 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
504
                    , errReasonPhrase :: String
errReasonPhrase = String
"Gateway Time-out"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }

-- | 'err505' HTTP Version not supported
--
-- Example usage:
--
-- > failingHandler :: Handler ()
-- > failingHandler = throwError $ err505 { errBody = "I support HTTP/4.0 only." }
--
err505 :: ServerError
err505 :: ServerError
err505 = ServerError { errHTTPCode :: Int
errHTTPCode = Int
505
                    , errReasonPhrase :: String
errReasonPhrase = String
"HTTP Version not supported"
                    , errBody :: ByteString
errBody = ByteString
""
                    , errHeaders :: [Header]
errHeaders = []
                    }