{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveFunctor, DeriveFoldable, DeriveTraversable #-}

module Data.JsonRpc.Failure (
  Failure (..), Error (..),
  ErrorStatus (..), toCode, fromCode, refineStatus,

  failure, makeError,
  serverError,
  methodError,
  emptyError,
  ) where

import Prelude hiding (userError)
import Control.Monad (MonadPlus, mplus, guard)
import Data.Maybe (fromMaybe)
import Data.Text (Text)
import Data.Foldable (Foldable)
import Data.Traversable (Traversable)

import Data.JsonRpc.Id (Id)


data Failure e =
  Failure
  { Failure e -> Text
_jsonrpc :: !Text
  , Failure e -> Maybe Id
_id      :: !(Maybe Id)
  , Failure e -> Error e
_error   :: !(Error e)
  } deriving (Failure e -> Failure e -> Bool
(Failure e -> Failure e -> Bool)
-> (Failure e -> Failure e -> Bool) -> Eq (Failure e)
forall e. Eq e => Failure e -> Failure e -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Failure e -> Failure e -> Bool
$c/= :: forall e. Eq e => Failure e -> Failure e -> Bool
== :: Failure e -> Failure e -> Bool
$c== :: forall e. Eq e => Failure e -> Failure e -> Bool
Eq, Int -> Failure e -> ShowS
[Failure e] -> ShowS
Failure e -> String
(Int -> Failure e -> ShowS)
-> (Failure e -> String)
-> ([Failure e] -> ShowS)
-> Show (Failure e)
forall e. Show e => Int -> Failure e -> ShowS
forall e. Show e => [Failure e] -> ShowS
forall e. Show e => Failure e -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Failure e] -> ShowS
$cshowList :: forall e. Show e => [Failure e] -> ShowS
show :: Failure e -> String
$cshow :: forall e. Show e => Failure e -> String
showsPrec :: Int -> Failure e -> ShowS
$cshowsPrec :: forall e. Show e => Int -> Failure e -> ShowS
Show, a -> Failure b -> Failure a
(a -> b) -> Failure a -> Failure b
(forall a b. (a -> b) -> Failure a -> Failure b)
-> (forall a b. a -> Failure b -> Failure a) -> Functor Failure
forall a b. a -> Failure b -> Failure a
forall a b. (a -> b) -> Failure a -> Failure b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Failure b -> Failure a
$c<$ :: forall a b. a -> Failure b -> Failure a
fmap :: (a -> b) -> Failure a -> Failure b
$cfmap :: forall a b. (a -> b) -> Failure a -> Failure b
Functor, Failure a -> Bool
(a -> m) -> Failure a -> m
(a -> b -> b) -> b -> Failure a -> b
(forall m. Monoid m => Failure m -> m)
-> (forall m a. Monoid m => (a -> m) -> Failure a -> m)
-> (forall m a. Monoid m => (a -> m) -> Failure a -> m)
-> (forall a b. (a -> b -> b) -> b -> Failure a -> b)
-> (forall a b. (a -> b -> b) -> b -> Failure a -> b)
-> (forall b a. (b -> a -> b) -> b -> Failure a -> b)
-> (forall b a. (b -> a -> b) -> b -> Failure a -> b)
-> (forall a. (a -> a -> a) -> Failure a -> a)
-> (forall a. (a -> a -> a) -> Failure a -> a)
-> (forall a. Failure a -> [a])
-> (forall a. Failure a -> Bool)
-> (forall a. Failure a -> Int)
-> (forall a. Eq a => a -> Failure a -> Bool)
-> (forall a. Ord a => Failure a -> a)
-> (forall a. Ord a => Failure a -> a)
-> (forall a. Num a => Failure a -> a)
-> (forall a. Num a => Failure a -> a)
-> Foldable Failure
forall a. Eq a => a -> Failure a -> Bool
forall a. Num a => Failure a -> a
forall a. Ord a => Failure a -> a
forall m. Monoid m => Failure m -> m
forall a. Failure a -> Bool
forall a. Failure a -> Int
forall a. Failure a -> [a]
forall a. (a -> a -> a) -> Failure a -> a
forall m a. Monoid m => (a -> m) -> Failure a -> m
forall b a. (b -> a -> b) -> b -> Failure a -> b
forall a b. (a -> b -> b) -> b -> Failure a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Failure a -> a
$cproduct :: forall a. Num a => Failure a -> a
sum :: Failure a -> a
$csum :: forall a. Num a => Failure a -> a
minimum :: Failure a -> a
$cminimum :: forall a. Ord a => Failure a -> a
maximum :: Failure a -> a
$cmaximum :: forall a. Ord a => Failure a -> a
elem :: a -> Failure a -> Bool
$celem :: forall a. Eq a => a -> Failure a -> Bool
length :: Failure a -> Int
$clength :: forall a. Failure a -> Int
null :: Failure a -> Bool
$cnull :: forall a. Failure a -> Bool
toList :: Failure a -> [a]
$ctoList :: forall a. Failure a -> [a]
foldl1 :: (a -> a -> a) -> Failure a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Failure a -> a
foldr1 :: (a -> a -> a) -> Failure a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Failure a -> a
foldl' :: (b -> a -> b) -> b -> Failure a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Failure a -> b
foldl :: (b -> a -> b) -> b -> Failure a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Failure a -> b
foldr' :: (a -> b -> b) -> b -> Failure a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Failure a -> b
foldr :: (a -> b -> b) -> b -> Failure a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Failure a -> b
foldMap' :: (a -> m) -> Failure a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Failure a -> m
foldMap :: (a -> m) -> Failure a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Failure a -> m
fold :: Failure m -> m
$cfold :: forall m. Monoid m => Failure m -> m
Foldable, Functor Failure
Foldable Failure
Functor Failure
-> Foldable Failure
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Failure a -> f (Failure b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Failure (f a) -> f (Failure a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Failure a -> m (Failure b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Failure (m a) -> m (Failure a))
-> Traversable Failure
(a -> f b) -> Failure a -> f (Failure b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Failure (m a) -> m (Failure a)
forall (f :: * -> *) a.
Applicative f =>
Failure (f a) -> f (Failure a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Failure a -> m (Failure b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Failure a -> f (Failure b)
sequence :: Failure (m a) -> m (Failure a)
$csequence :: forall (m :: * -> *) a. Monad m => Failure (m a) -> m (Failure a)
mapM :: (a -> m b) -> Failure a -> m (Failure b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Failure a -> m (Failure b)
sequenceA :: Failure (f a) -> f (Failure a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Failure (f a) -> f (Failure a)
traverse :: (a -> f b) -> Failure a -> f (Failure b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Failure a -> f (Failure b)
$cp2Traversable :: Foldable Failure
$cp1Traversable :: Functor Failure
Traversable)

data Error e =
  Error
  { Error e -> ErrorStatus
_code    :: !ErrorStatus
  , Error e -> Text
_message :: !Text
  , Error e -> Maybe e
_data    :: !(Maybe e)
  } deriving (Error e -> Error e -> Bool
(Error e -> Error e -> Bool)
-> (Error e -> Error e -> Bool) -> Eq (Error e)
forall e. Eq e => Error e -> Error e -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Error e -> Error e -> Bool
$c/= :: forall e. Eq e => Error e -> Error e -> Bool
== :: Error e -> Error e -> Bool
$c== :: forall e. Eq e => Error e -> Error e -> Bool
Eq, Int -> Error e -> ShowS
[Error e] -> ShowS
Error e -> String
(Int -> Error e -> ShowS)
-> (Error e -> String) -> ([Error e] -> ShowS) -> Show (Error e)
forall e. Show e => Int -> Error e -> ShowS
forall e. Show e => [Error e] -> ShowS
forall e. Show e => Error e -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Error e] -> ShowS
$cshowList :: forall e. Show e => [Error e] -> ShowS
show :: Error e -> String
$cshow :: forall e. Show e => Error e -> String
showsPrec :: Int -> Error e -> ShowS
$cshowsPrec :: forall e. Show e => Int -> Error e -> ShowS
Show, a -> Error b -> Error a
(a -> b) -> Error a -> Error b
(forall a b. (a -> b) -> Error a -> Error b)
-> (forall a b. a -> Error b -> Error a) -> Functor Error
forall a b. a -> Error b -> Error a
forall a b. (a -> b) -> Error a -> Error b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Error b -> Error a
$c<$ :: forall a b. a -> Error b -> Error a
fmap :: (a -> b) -> Error a -> Error b
$cfmap :: forall a b. (a -> b) -> Error a -> Error b
Functor, Error a -> Bool
(a -> m) -> Error a -> m
(a -> b -> b) -> b -> Error a -> b
(forall m. Monoid m => Error m -> m)
-> (forall m a. Monoid m => (a -> m) -> Error a -> m)
-> (forall m a. Monoid m => (a -> m) -> Error a -> m)
-> (forall a b. (a -> b -> b) -> b -> Error a -> b)
-> (forall a b. (a -> b -> b) -> b -> Error a -> b)
-> (forall b a. (b -> a -> b) -> b -> Error a -> b)
-> (forall b a. (b -> a -> b) -> b -> Error a -> b)
-> (forall a. (a -> a -> a) -> Error a -> a)
-> (forall a. (a -> a -> a) -> Error a -> a)
-> (forall a. Error a -> [a])
-> (forall a. Error a -> Bool)
-> (forall a. Error a -> Int)
-> (forall a. Eq a => a -> Error a -> Bool)
-> (forall a. Ord a => Error a -> a)
-> (forall a. Ord a => Error a -> a)
-> (forall a. Num a => Error a -> a)
-> (forall a. Num a => Error a -> a)
-> Foldable Error
forall a. Eq a => a -> Error a -> Bool
forall a. Num a => Error a -> a
forall a. Ord a => Error a -> a
forall m. Monoid m => Error m -> m
forall a. Error a -> Bool
forall a. Error a -> Int
forall a. Error a -> [a]
forall a. (a -> a -> a) -> Error a -> a
forall m a. Monoid m => (a -> m) -> Error a -> m
forall b a. (b -> a -> b) -> b -> Error a -> b
forall a b. (a -> b -> b) -> b -> Error a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Error a -> a
$cproduct :: forall a. Num a => Error a -> a
sum :: Error a -> a
$csum :: forall a. Num a => Error a -> a
minimum :: Error a -> a
$cminimum :: forall a. Ord a => Error a -> a
maximum :: Error a -> a
$cmaximum :: forall a. Ord a => Error a -> a
elem :: a -> Error a -> Bool
$celem :: forall a. Eq a => a -> Error a -> Bool
length :: Error a -> Int
$clength :: forall a. Error a -> Int
null :: Error a -> Bool
$cnull :: forall a. Error a -> Bool
toList :: Error a -> [a]
$ctoList :: forall a. Error a -> [a]
foldl1 :: (a -> a -> a) -> Error a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Error a -> a
foldr1 :: (a -> a -> a) -> Error a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Error a -> a
foldl' :: (b -> a -> b) -> b -> Error a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Error a -> b
foldl :: (b -> a -> b) -> b -> Error a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Error a -> b
foldr' :: (a -> b -> b) -> b -> Error a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Error a -> b
foldr :: (a -> b -> b) -> b -> Error a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Error a -> b
foldMap' :: (a -> m) -> Error a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Error a -> m
foldMap :: (a -> m) -> Error a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Error a -> m
fold :: Error m -> m
$cfold :: forall m. Monoid m => Error m -> m
Foldable, Functor Error
Foldable Error
Functor Error
-> Foldable Error
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Error a -> f (Error b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Error (f a) -> f (Error a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Error a -> m (Error b))
-> (forall (m :: * -> *) a. Monad m => Error (m a) -> m (Error a))
-> Traversable Error
(a -> f b) -> Error a -> f (Error b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Error (m a) -> m (Error a)
forall (f :: * -> *) a. Applicative f => Error (f a) -> f (Error a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Error a -> m (Error b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Error a -> f (Error b)
sequence :: Error (m a) -> m (Error a)
$csequence :: forall (m :: * -> *) a. Monad m => Error (m a) -> m (Error a)
mapM :: (a -> m b) -> Error a -> m (Error b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Error a -> m (Error b)
sequenceA :: Error (f a) -> f (Error a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Error (f a) -> f (Error a)
traverse :: (a -> f b) -> Error a -> f (Error b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Error a -> f (Error b)
$cp2Traversable :: Foldable Error
$cp1Traversable :: Functor Error
Traversable)

{-
-- citation from http://www.jsonrpc.org/specification
--
-- The error codes from and including -32768 to -32000 are reserved for pre-defined errors.
-- Any code within this range, but not defined explicitly below is reserved for future use.
-- The error codes are nearly the same as those suggested for XML-RPC at the following
-- url: http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php
--
-- code               message            meaning
-- -32700             Parse error        Invalid JSON was received by the server.
--                                       An error occurred on the server while parsing the JSON text.
-- -32600             Invalid Request    The JSON sent is not a valid Request object.
-- -32601             Method not found   The method does not exist / is not available.
-- -32602             Invalid params     Invalid method parameter(s).
-- -32603             Internal error     Internal JSON-RPC error.
-- -32000 to -32099   Server error       Reserved for implementation-defined server-errors.

-- The remainder of the space is available for application defined errors.
 -}
data ErrorStatus
  = ParseError
  | InvalidRequest
  | MethodNotFound
  | InvalidParams
  | InternalError
  | ServerError !Integer
  | MethodError !Integer
  deriving (ErrorStatus -> ErrorStatus -> Bool
(ErrorStatus -> ErrorStatus -> Bool)
-> (ErrorStatus -> ErrorStatus -> Bool) -> Eq ErrorStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ErrorStatus -> ErrorStatus -> Bool
$c/= :: ErrorStatus -> ErrorStatus -> Bool
== :: ErrorStatus -> ErrorStatus -> Bool
$c== :: ErrorStatus -> ErrorStatus -> Bool
Eq, Int -> ErrorStatus -> ShowS
[ErrorStatus] -> ShowS
ErrorStatus -> String
(Int -> ErrorStatus -> ShowS)
-> (ErrorStatus -> String)
-> ([ErrorStatus] -> ShowS)
-> Show ErrorStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ErrorStatus] -> ShowS
$cshowList :: [ErrorStatus] -> ShowS
show :: ErrorStatus -> String
$cshow :: ErrorStatus -> String
showsPrec :: Int -> ErrorStatus -> ShowS
$cshowsPrec :: Int -> ErrorStatus -> ShowS
Show)

failure :: Maybe Id -> ErrorStatus -> Maybe Text -> Maybe e -> Failure e
failure :: Maybe Id -> ErrorStatus -> Maybe Text -> Maybe e -> Failure e
failure Maybe Id
mayId ErrorStatus
s Maybe Text
mm =
  Text -> Maybe Id -> Error e -> Failure e
forall e. Text -> Maybe Id -> Error e -> Failure e
Failure Text
"2.0" Maybe Id
mayId (Error e -> Failure e)
-> (Maybe e -> Error e) -> Maybe e -> Failure e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ErrorStatus -> Maybe Text -> Maybe e -> Error e
forall e. ErrorStatus -> Maybe Text -> Maybe e -> Error e
makeError ErrorStatus
s Maybe Text
mm

defaultMessage :: ErrorStatus -> Text
defaultMessage :: ErrorStatus -> Text
defaultMessage = ErrorStatus -> Text
forall p. IsString p => ErrorStatus -> p
d  where
  d :: ErrorStatus -> p
d  ErrorStatus
ParseError         =  p
"Parse error"
  d  ErrorStatus
InvalidRequest     =  p
"Invalid Request"
  d  ErrorStatus
MethodNotFound     =  p
"Method not found"
  d  ErrorStatus
InvalidParams      =  p
"Invalid params"
  d  ErrorStatus
InternalError      =  p
"Internal error"
  d (ServerError Integer
_)     =  p
"Server error"
  d (MethodError Integer
_)     =  p
"Application method error"

toCode :: ErrorStatus -> Integer
toCode :: ErrorStatus -> Integer
toCode = ErrorStatus -> Integer
d  where
  d :: ErrorStatus -> Integer
d  ErrorStatus
ParseError         =  -Integer
32700
  d  ErrorStatus
InvalidRequest     =  -Integer
32600
  d  ErrorStatus
MethodNotFound     =  -Integer
32601
  d  ErrorStatus
InvalidParams      =  -Integer
32602
  d  ErrorStatus
InternalError      =  -Integer
32603
  d (ServerError Integer
c)     =       Integer
c
  d (MethodError Integer
c)     =       Integer
c

fromCode :: (Integral a, MonadPlus m)
         => a
         -> m ErrorStatus
fromCode :: a -> m ErrorStatus
fromCode a
c'
  | Integer
c Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== -Integer
32700  =  ErrorStatus -> m ErrorStatus
forall (m :: * -> *) a. Monad m => a -> m a
return ErrorStatus
ParseError
  | Integer
c Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== -Integer
32600  =  ErrorStatus -> m ErrorStatus
forall (m :: * -> *) a. Monad m => a -> m a
return ErrorStatus
InvalidRequest
  | Integer
c Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== -Integer
32601  =  ErrorStatus -> m ErrorStatus
forall (m :: * -> *) a. Monad m => a -> m a
return ErrorStatus
MethodNotFound
  | Integer
c Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== -Integer
32602  =  ErrorStatus -> m ErrorStatus
forall (m :: * -> *) a. Monad m => a -> m a
return ErrorStatus
InvalidParams
  | Integer
c Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== -Integer
32603  =  ErrorStatus -> m ErrorStatus
forall (m :: * -> *) a. Monad m => a -> m a
return ErrorStatus
InternalError
  | Bool
otherwise    =  Integer -> m ErrorStatus
forall a (m :: * -> *).
(Integral a, MonadPlus m) =>
a -> m ErrorStatus
serverError Integer
c m ErrorStatus -> m ErrorStatus -> m ErrorStatus
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` Integer -> m ErrorStatus
forall a (m :: * -> *).
(Integral a, MonadPlus m) =>
a -> m ErrorStatus
methodError Integer
c
  where
    c :: Integer
c = a -> Integer
forall a. Integral a => a -> Integer
toInteger a
c'

refineStatus :: MonadPlus m
             => ErrorStatus
             -> m ErrorStatus
refineStatus :: ErrorStatus -> m ErrorStatus
refineStatus ErrorStatus
e = do
  ErrorStatus
e' <- Integer -> m ErrorStatus
forall a (m :: * -> *).
(Integral a, MonadPlus m) =>
a -> m ErrorStatus
fromCode (Integer -> m ErrorStatus) -> Integer -> m ErrorStatus
forall a b. (a -> b) -> a -> b
$ ErrorStatus -> Integer
toCode ErrorStatus
e
  Bool -> m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> m ()) -> Bool -> m ()
forall a b. (a -> b) -> a -> b
$ ErrorStatus
e' ErrorStatus -> ErrorStatus -> Bool
forall a. Eq a => a -> a -> Bool
== ErrorStatus
e
  ErrorStatus -> m ErrorStatus
forall (m :: * -> *) a. Monad m => a -> m a
return ErrorStatus
e

makeError :: ErrorStatus -> Maybe Text -> Maybe e -> Error e
makeError :: ErrorStatus -> Maybe Text -> Maybe e -> Error e
makeError ErrorStatus
e = ErrorStatus -> Text -> Maybe e -> Error e
forall e. ErrorStatus -> Text -> Maybe e -> Error e
Error ErrorStatus
e (Text -> Maybe e -> Error e)
-> (Maybe Text -> Text) -> Maybe Text -> Maybe e -> Error e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe (ErrorStatus -> Text
defaultMessage ErrorStatus
e)

serverError :: (Integral a, MonadPlus m)
            => a
            -> m ErrorStatus
serverError :: a -> m ErrorStatus
serverError a
c' = do
  let c :: Integer
c = a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
c'
  Bool -> m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> m ()) -> Bool -> m ()
forall a b. (a -> b) -> a -> b
$ -Integer
32099 Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
c Bool -> Bool -> Bool
&& Integer
c Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= -Integer
32000
  ErrorStatus -> m ErrorStatus
forall (m :: * -> *) a. Monad m => a -> m a
return (ErrorStatus -> m ErrorStatus) -> ErrorStatus -> m ErrorStatus
forall a b. (a -> b) -> a -> b
$ Integer -> ErrorStatus
ServerError Integer
c

methodError :: (Integral a, MonadPlus m)
            => a
            -> m ErrorStatus
methodError :: a -> m ErrorStatus
methodError a
c' = do
  let c :: Integer
c = a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
c'
  Bool -> m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> m ()) -> Bool -> m ()
forall a b. (a -> b) -> a -> b
$ Integer
c Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< -Integer
32768 Bool -> Bool -> Bool
|| -Integer
32000 Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
c
  ErrorStatus -> m ErrorStatus
forall (m :: * -> *) a. Monad m => a -> m a
return (ErrorStatus -> m ErrorStatus) -> ErrorStatus -> m ErrorStatus
forall a b. (a -> b) -> a -> b
$ Integer -> ErrorStatus
MethodError Integer
c

emptyError :: Maybe ()
emptyError :: Maybe ()
emptyError = Maybe ()
forall a. Maybe a
Nothing