{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE OverloadedStrings  #-}

-- |
-- Module      : Network.OAuth.Type.Credentials
-- Copyright   : (c) Joseph Abrahamson 2013
-- License     : MIT
--
-- Maintainer  : me@jspha.com
-- Stability   : experimental
-- Portability : non-portable
--
-- Credentials, 'Cred's, are built from 'Token's, public/private key pairs, and
-- come in 3 varieties.
--
-- - 'Client': Represents a particular client or consumer, used as part of
-- every transaction that client signs.
--
-- - 'Temporary': Resource token representing a short-lived grant to access a
-- restricted set of server resources on behalf of the user. Typically used as
-- part of a authorization negotiation protocol.
--
-- - 'Permanent': Resource token representing a long-lived grant to access an
-- authorized set of server resources on behalf of the user. Outside of access
-- negotiation this is the most common kind of resource 'Token'.

-- 'Token's are constructed freely from public/private pairs and have
-- 'FromJSON' instances for easy retreival. 'Cred's are more strictly
-- controlled and must be constructed out of a 'Client' 'Token' and
-- (optionally) some kind of resource 'Token'.

module Network.OAuth.Types.Credentials (
  -- * Tokens and their parameterization
  Token (..), Key, Secret, Client, Temporary, Permanent, ResourceToken,

  -- ** Deserialization
  fromUrlEncoded,

  -- * Credentials and credential construction
  Cred, clientCred, temporaryCred, permanentCred, upgradeCred,

  -- * Accessors
  key, secret, clientToken, resourceToken, getResourceTokenDef, signingKey
  ) where

import           Control.Applicative
import           Control.Monad
import           Data.Aeson hiding (Key)
import qualified Data.ByteString      as S
import           Data.Data
import           Network.HTTP.Types   (parseQuery, urlEncode)
import           Network.OAuth.Util
import           Data.Text.Encoding (decodeLatin1, encodeUtf8)

-- Constructors aren't exported. They're only used for derivation
-- purposes.

-- | 'Client' 'Cred'entials and 'Token's are assigned to a particular client by
-- the server and are used for all requests sent by that client. They form the
-- core component of resource specific credentials.
data Client    = Client    deriving ( Typeable Client
DataType
Constr
Typeable Client
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Client -> c Client)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Client)
-> (Client -> Constr)
-> (Client -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Client))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Client))
-> ((forall b. Data b => b -> b) -> Client -> Client)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Client -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Client -> r)
-> (forall u. (forall d. Data d => d -> u) -> Client -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Client -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Client -> m Client)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Client -> m Client)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Client -> m Client)
-> Data Client
Client -> DataType
Client -> Constr
(forall b. Data b => b -> b) -> Client -> Client
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Client -> c Client
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Client
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Client -> u
forall u. (forall d. Data d => d -> u) -> Client -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Client -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Client -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Client -> m Client
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Client -> m Client
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Client
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Client -> c Client
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Client)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Client)
$cClient :: Constr
$tClient :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Client -> m Client
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Client -> m Client
gmapMp :: (forall d. Data d => d -> m d) -> Client -> m Client
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Client -> m Client
gmapM :: (forall d. Data d => d -> m d) -> Client -> m Client
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Client -> m Client
gmapQi :: Int -> (forall d. Data d => d -> u) -> Client -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Client -> u
gmapQ :: (forall d. Data d => d -> u) -> Client -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Client -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Client -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Client -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Client -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Client -> r
gmapT :: (forall b. Data b => b -> b) -> Client -> Client
$cgmapT :: (forall b. Data b => b -> b) -> Client -> Client
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Client)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Client)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Client)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Client)
dataTypeOf :: Client -> DataType
$cdataTypeOf :: Client -> DataType
toConstr :: Client -> Constr
$ctoConstr :: Client -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Client
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Client
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Client -> c Client
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Client -> c Client
$cp1Data :: Typeable Client
Data, Typeable )

-- | 'Temporary' 'Token's and 'Cred'entials are created during authorization
-- protocols and are rarely meant to be kept for more than a few minutes.
-- Typically they are authorized to access only a very select set of server
-- resources. During \"three-legged authorization\" in OAuth 1.0 they are used
-- to generate the authorization request URI the client sends and, after that,
-- in the 'Permanent' 'Token' request.
data Temporary = Temporary deriving ( Typeable Temporary
DataType
Constr
Typeable Temporary
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Temporary -> c Temporary)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Temporary)
-> (Temporary -> Constr)
-> (Temporary -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Temporary))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Temporary))
-> ((forall b. Data b => b -> b) -> Temporary -> Temporary)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Temporary -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Temporary -> r)
-> (forall u. (forall d. Data d => d -> u) -> Temporary -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Temporary -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Temporary -> m Temporary)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Temporary -> m Temporary)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Temporary -> m Temporary)
-> Data Temporary
Temporary -> DataType
Temporary -> Constr
(forall b. Data b => b -> b) -> Temporary -> Temporary
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Temporary -> c Temporary
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Temporary
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Temporary -> u
forall u. (forall d. Data d => d -> u) -> Temporary -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Temporary -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Temporary -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Temporary -> m Temporary
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Temporary -> m Temporary
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Temporary
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Temporary -> c Temporary
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Temporary)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Temporary)
$cTemporary :: Constr
$tTemporary :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Temporary -> m Temporary
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Temporary -> m Temporary
gmapMp :: (forall d. Data d => d -> m d) -> Temporary -> m Temporary
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Temporary -> m Temporary
gmapM :: (forall d. Data d => d -> m d) -> Temporary -> m Temporary
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Temporary -> m Temporary
gmapQi :: Int -> (forall d. Data d => d -> u) -> Temporary -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Temporary -> u
gmapQ :: (forall d. Data d => d -> u) -> Temporary -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Temporary -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Temporary -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Temporary -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Temporary -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Temporary -> r
gmapT :: (forall b. Data b => b -> b) -> Temporary -> Temporary
$cgmapT :: (forall b. Data b => b -> b) -> Temporary -> Temporary
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Temporary)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Temporary)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Temporary)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Temporary)
dataTypeOf :: Temporary -> DataType
$cdataTypeOf :: Temporary -> DataType
toConstr :: Temporary -> Constr
$ctoConstr :: Temporary -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Temporary
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Temporary
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Temporary -> c Temporary
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Temporary -> c Temporary
$cp1Data :: Typeable Temporary
Data, Typeable )

-- | 'Permanent' 'Token's and 'Cred'entials are the primary means of accessing
-- server resources. They must be maintained by the client for each user who
-- authorizes that client to access resources on their behalf.
data Permanent = Permanent deriving ( Typeable Permanent
DataType
Constr
Typeable Permanent
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Permanent -> c Permanent)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Permanent)
-> (Permanent -> Constr)
-> (Permanent -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Permanent))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Permanent))
-> ((forall b. Data b => b -> b) -> Permanent -> Permanent)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Permanent -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Permanent -> r)
-> (forall u. (forall d. Data d => d -> u) -> Permanent -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Permanent -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Permanent -> m Permanent)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Permanent -> m Permanent)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Permanent -> m Permanent)
-> Data Permanent
Permanent -> DataType
Permanent -> Constr
(forall b. Data b => b -> b) -> Permanent -> Permanent
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Permanent -> c Permanent
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Permanent
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Permanent -> u
forall u. (forall d. Data d => d -> u) -> Permanent -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Permanent -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Permanent -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Permanent -> m Permanent
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Permanent -> m Permanent
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Permanent
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Permanent -> c Permanent
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Permanent)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Permanent)
$cPermanent :: Constr
$tPermanent :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Permanent -> m Permanent
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Permanent -> m Permanent
gmapMp :: (forall d. Data d => d -> m d) -> Permanent -> m Permanent
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Permanent -> m Permanent
gmapM :: (forall d. Data d => d -> m d) -> Permanent -> m Permanent
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Permanent -> m Permanent
gmapQi :: Int -> (forall d. Data d => d -> u) -> Permanent -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Permanent -> u
gmapQ :: (forall d. Data d => d -> u) -> Permanent -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Permanent -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Permanent -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Permanent -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Permanent -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Permanent -> r
gmapT :: (forall b. Data b => b -> b) -> Permanent -> Permanent
$cgmapT :: (forall b. Data b => b -> b) -> Permanent -> Permanent
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Permanent)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Permanent)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Permanent)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Permanent)
dataTypeOf :: Permanent -> DataType
$cdataTypeOf :: Permanent -> DataType
toConstr :: Permanent -> Constr
$ctoConstr :: Permanent -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Permanent
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Permanent
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Permanent -> c Permanent
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Permanent -> c Permanent
$cp1Data :: Typeable Permanent
Data, Typeable )

-- | 'Token' 'Key's are public keys which allow a server to uniquely identify a
-- particular 'Token'.
type Key    = S.ByteString

-- | 'Token' 'Secret's are private keys which the 'Token' uses for
-- cryptographic purposes.
type Secret = S.ByteString

-- | 'Token's are public, private key pairs and come in many varieties,
-- 'Client', 'Temporary', and 'Permanent'.
data Token ty = Token {-# UNPACK #-} !Key
                      {-# UNPACK #-} !Secret
  deriving ( Int -> Token ty -> ShowS
[Token ty] -> ShowS
Token ty -> String
(Int -> Token ty -> ShowS)
-> (Token ty -> String) -> ([Token ty] -> ShowS) -> Show (Token ty)
forall ty. Int -> Token ty -> ShowS
forall ty. [Token ty] -> ShowS
forall ty. Token ty -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Token ty] -> ShowS
$cshowList :: forall ty. [Token ty] -> ShowS
show :: Token ty -> String
$cshow :: forall ty. Token ty -> String
showsPrec :: Int -> Token ty -> ShowS
$cshowsPrec :: forall ty. Int -> Token ty -> ShowS
Show, Token ty -> Token ty -> Bool
(Token ty -> Token ty -> Bool)
-> (Token ty -> Token ty -> Bool) -> Eq (Token ty)
forall ty. Token ty -> Token ty -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Token ty -> Token ty -> Bool
$c/= :: forall ty. Token ty -> Token ty -> Bool
== :: Token ty -> Token ty -> Bool
$c== :: forall ty. Token ty -> Token ty -> Bool
Eq, Eq (Token ty)
Eq (Token ty)
-> (Token ty -> Token ty -> Ordering)
-> (Token ty -> Token ty -> Bool)
-> (Token ty -> Token ty -> Bool)
-> (Token ty -> Token ty -> Bool)
-> (Token ty -> Token ty -> Bool)
-> (Token ty -> Token ty -> Token ty)
-> (Token ty -> Token ty -> Token ty)
-> Ord (Token ty)
Token ty -> Token ty -> Bool
Token ty -> Token ty -> Ordering
Token ty -> Token ty -> Token ty
forall ty. Eq (Token ty)
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall ty. Token ty -> Token ty -> Bool
forall ty. Token ty -> Token ty -> Ordering
forall ty. Token ty -> Token ty -> Token ty
min :: Token ty -> Token ty -> Token ty
$cmin :: forall ty. Token ty -> Token ty -> Token ty
max :: Token ty -> Token ty -> Token ty
$cmax :: forall ty. Token ty -> Token ty -> Token ty
>= :: Token ty -> Token ty -> Bool
$c>= :: forall ty. Token ty -> Token ty -> Bool
> :: Token ty -> Token ty -> Bool
$c> :: forall ty. Token ty -> Token ty -> Bool
<= :: Token ty -> Token ty -> Bool
$c<= :: forall ty. Token ty -> Token ty -> Bool
< :: Token ty -> Token ty -> Bool
$c< :: forall ty. Token ty -> Token ty -> Bool
compare :: Token ty -> Token ty -> Ordering
$ccompare :: forall ty. Token ty -> Token ty -> Ordering
$cp1Ord :: forall ty. Eq (Token ty)
Ord, Typeable (Token ty)
DataType
Constr
Typeable (Token ty)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Token ty -> c (Token ty))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Token ty))
-> (Token ty -> Constr)
-> (Token ty -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Token ty)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Token ty)))
-> ((forall b. Data b => b -> b) -> Token ty -> Token ty)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Token ty -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Token ty -> r)
-> (forall u. (forall d. Data d => d -> u) -> Token ty -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Token ty -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Token ty -> m (Token ty))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Token ty -> m (Token ty))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Token ty -> m (Token ty))
-> Data (Token ty)
Token ty -> DataType
Token ty -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Token ty))
(forall b. Data b => b -> b) -> Token ty -> Token ty
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Token ty -> c (Token ty)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Token ty)
forall ty. Data ty => Typeable (Token ty)
forall ty. Data ty => Token ty -> DataType
forall ty. Data ty => Token ty -> Constr
forall ty.
Data ty =>
(forall b. Data b => b -> b) -> Token ty -> Token ty
forall ty u.
Data ty =>
Int -> (forall d. Data d => d -> u) -> Token ty -> u
forall ty u.
Data ty =>
(forall d. Data d => d -> u) -> Token ty -> [u]
forall ty r r'.
Data ty =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Token ty -> r
forall ty r r'.
Data ty =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Token ty -> r
forall ty (m :: * -> *).
(Data ty, Monad m) =>
(forall d. Data d => d -> m d) -> Token ty -> m (Token ty)
forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Token ty -> m (Token ty)
forall ty (c :: * -> *).
Data ty =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Token ty)
forall ty (c :: * -> *).
Data ty =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Token ty -> c (Token ty)
forall ty (t :: * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Token ty))
forall ty (t :: * -> * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Token ty))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Token ty -> u
forall u. (forall d. Data d => d -> u) -> Token ty -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Token ty -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Token ty -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Token ty -> m (Token ty)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Token ty -> m (Token ty)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Token ty)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Token ty -> c (Token ty)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Token ty))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Token ty))
$cToken :: Constr
$tToken :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Token ty -> m (Token ty)
$cgmapMo :: forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Token ty -> m (Token ty)
gmapMp :: (forall d. Data d => d -> m d) -> Token ty -> m (Token ty)
$cgmapMp :: forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Token ty -> m (Token ty)
gmapM :: (forall d. Data d => d -> m d) -> Token ty -> m (Token ty)
$cgmapM :: forall ty (m :: * -> *).
(Data ty, Monad m) =>
(forall d. Data d => d -> m d) -> Token ty -> m (Token ty)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Token ty -> u
$cgmapQi :: forall ty u.
Data ty =>
Int -> (forall d. Data d => d -> u) -> Token ty -> u
gmapQ :: (forall d. Data d => d -> u) -> Token ty -> [u]
$cgmapQ :: forall ty u.
Data ty =>
(forall d. Data d => d -> u) -> Token ty -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Token ty -> r
$cgmapQr :: forall ty r r'.
Data ty =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Token ty -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Token ty -> r
$cgmapQl :: forall ty r r'.
Data ty =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Token ty -> r
gmapT :: (forall b. Data b => b -> b) -> Token ty -> Token ty
$cgmapT :: forall ty.
Data ty =>
(forall b. Data b => b -> b) -> Token ty -> Token ty
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Token ty))
$cdataCast2 :: forall ty (t :: * -> * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Token ty))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Token ty))
$cdataCast1 :: forall ty (t :: * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Token ty))
dataTypeOf :: Token ty -> DataType
$cdataTypeOf :: forall ty. Data ty => Token ty -> DataType
toConstr :: Token ty -> Constr
$ctoConstr :: forall ty. Data ty => Token ty -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Token ty)
$cgunfold :: forall ty (c :: * -> *).
Data ty =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Token ty)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Token ty -> c (Token ty)
$cgfoldl :: forall ty (c :: * -> *).
Data ty =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Token ty -> c (Token ty)
$cp1Data :: forall ty. Data ty => Typeable (Token ty)
Data, Typeable )

class ResourceToken tk where
  upgradeCred' :: Token tk -> Cred tk' -> Cred tk
  upgradeCred' Token tk
tok (Cred         Key
k Key
s  ) = Key -> Key -> Token tk -> Cred tk
forall ty. Key -> Key -> Token ty -> Cred ty
CredAndToken Key
k Key
s Token tk
tok
  upgradeCred' Token tk
tok (CredAndToken Key
k Key
s Token tk'
_) = Key -> Key -> Token tk -> Cred tk
forall ty. Key -> Key -> Token ty -> Cred ty
CredAndToken Key
k Key
s Token tk
tok

instance ResourceToken Temporary
instance ResourceToken Permanent

upgradeCred :: ResourceToken tk => Token tk -> Cred tk' -> Cred tk
upgradeCred :: Token tk -> Cred tk' -> Cred tk
upgradeCred = Token tk -> Cred tk' -> Cred tk
forall tk tk'. ResourceToken tk => Token tk -> Cred tk' -> Cred tk
upgradeCred'

-- | Parses a JSON object with keys @oauth_token@ and @oauth_token_secret@, the
-- standard format for OAuth 1.0.
instance FromJSON (Token ty) where
  parseJSON :: Value -> Parser (Token ty)
parseJSON = String
-> (Object -> Parser (Token ty)) -> Value -> Parser (Token ty)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"OAuth Token" ((Object -> Parser (Token ty)) -> Value -> Parser (Token ty))
-> (Object -> Parser (Token ty)) -> Value -> Parser (Token ty)
forall a b. (a -> b) -> a -> b
$ \Object
o ->
    Key -> Key -> Token ty
forall ty. Key -> Key -> Token ty
Token (Key -> Key -> Token ty) -> Parser Key -> Parser (Key -> Token ty)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Text -> Key) -> Parser Text -> Parser Key
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> Key
encodeUtf8 (Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"oauth_token")
          Parser (Key -> Token ty) -> Parser Key -> Parser (Token ty)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Text -> Key) -> Parser Text -> Parser Key
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> Key
encodeUtf8 (Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"oauth_token_secret")

-- | Produces a JSON object using keys named @oauth_token@ and
-- @oauth_token_secret@.
instance ToJSON (Token ty) where
  toJSON :: Token ty -> Value
toJSON (Token Key
k Key
s) = [Pair] -> Value
object [ Key
"oauth_token"        Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (Key -> Text
decodeLatin1 Key
k)
                              , Key
"oauth_token_secret" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (Key -> Text
decodeLatin1 Key
s)
                              ]

-- | Parses a @www-form-urlencoded@ stream to produce a 'Token' if possible.
-- The first result value is whether or not the token data is OAuth 1.0a
-- compatible.
--
-- >>> fromUrlEncoded "oauth_token=key&oauth_token_secret=secret"
-- Just (False, Token "key" "secret")
--
-- >>> fromUrlEncoded "oauth_token=key&oauth_token_secret=secret&oauth_callback_confirmed=true"
-- Just (True, Token "key" "secret")
--
fromUrlEncoded :: S.ByteString -> Maybe (Bool, Token ty)
fromUrlEncoded :: Key -> Maybe (Bool, Token ty)
fromUrlEncoded = [(Key, Maybe Key)] -> Maybe (Bool, Token ty)
forall a ty.
(Eq a, IsString a) =>
[(a, Maybe Key)] -> Maybe (Bool, Token ty)
tryParse ([(Key, Maybe Key)] -> Maybe (Bool, Token ty))
-> (Key -> [(Key, Maybe Key)]) -> Key -> Maybe (Bool, Token ty)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Key -> [(Key, Maybe Key)]
parseQuery where
  tryParse :: [(a, Maybe Key)] -> Maybe (Bool, Token ty)
tryParse [(a, Maybe Key)]
q = do
    Token ty
tok <- Key -> Key -> Token ty
forall ty. Key -> Key -> Token ty
Token (Key -> Key -> Token ty) -> Maybe Key -> Maybe (Key -> Token ty)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> [(a, Maybe Key)] -> Maybe Key
forall a a. Eq a => a -> [(a, Maybe a)] -> Maybe a
lookupV a
"oauth_token"        [(a, Maybe Key)]
q
                 Maybe (Key -> Token ty) -> Maybe Key -> Maybe (Token ty)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> [(a, Maybe Key)] -> Maybe Key
forall a a. Eq a => a -> [(a, Maybe a)] -> Maybe a
lookupV a
"oauth_token_secret" [(a, Maybe Key)]
q
    Key
confirmed <- a -> [(a, Maybe Key)] -> Maybe Key
forall a a. Eq a => a -> [(a, Maybe a)] -> Maybe a
lookupV a
"oauth_callback_confirmed" [(a, Maybe Key)]
q Maybe Key -> Maybe Key -> Maybe Key
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Key -> Maybe Key
forall (f :: * -> *) a. Applicative f => a -> f a
pure Key
""
    (Bool, Token ty) -> Maybe (Bool, Token ty)
forall (m :: * -> *) a. Monad m => a -> m a
return (Key
confirmed Key -> Key -> Bool
forall a. Eq a => a -> a -> Bool
== Key
"true", Token ty
tok)

  lookupV :: a -> [(a, Maybe a)] -> Maybe a
lookupV a
k = Maybe (Maybe a) -> Maybe a
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (Maybe (Maybe a) -> Maybe a)
-> ([(a, Maybe a)] -> Maybe (Maybe a)) -> [(a, Maybe a)] -> Maybe a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [(a, Maybe a)] -> Maybe (Maybe a)
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup a
k

-- | Lens on the key component of a 'Token'.
key :: Functor f => (Key -> f Key) -> Token ty -> f (Token ty)
key :: (Key -> f Key) -> Token ty -> f (Token ty)
key Key -> f Key
inj (Token Key
k Key
s) = (Key -> Key -> Token ty
forall ty. Key -> Key -> Token ty
`Token` Key
s) (Key -> Token ty) -> f Key -> f (Token ty)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Key -> f Key
inj Key
k
{-# INLINE key #-}

-- | Lens on the key secret component of a 'Token'.
secret :: Functor f => (Secret -> f Secret) -> Token ty -> f (Token ty)
secret :: (Key -> f Key) -> Token ty -> f (Token ty)
secret Key -> f Key
inj (Token Key
k Key
s) = Key -> Key -> Token ty
forall ty. Key -> Key -> Token ty
Token Key
k (Key -> Token ty) -> f Key -> f (Token ty)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Key -> f Key
inj Key
s
{-# INLINE secret #-}

-- | 'Cred'entials pair a 'Client' 'Token' and either a 'Temporary' or
-- 'Permanent' token corresponding to a particular set of user
-- resources on the server.
data Cred ty = Cred         {-# UNPACK #-} !Key {-# UNPACK #-} !Secret
             | CredAndToken {-# UNPACK #-} !Key {-# UNPACK #-} !Secret {-# UNPACK #-} !(Token ty)
  deriving ( Int -> Cred ty -> ShowS
[Cred ty] -> ShowS
Cred ty -> String
(Int -> Cred ty -> ShowS)
-> (Cred ty -> String) -> ([Cred ty] -> ShowS) -> Show (Cred ty)
forall ty. Int -> Cred ty -> ShowS
forall ty. [Cred ty] -> ShowS
forall ty. Cred ty -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Cred ty] -> ShowS
$cshowList :: forall ty. [Cred ty] -> ShowS
show :: Cred ty -> String
$cshow :: forall ty. Cred ty -> String
showsPrec :: Int -> Cred ty -> ShowS
$cshowsPrec :: forall ty. Int -> Cred ty -> ShowS
Show, Cred ty -> Cred ty -> Bool
(Cred ty -> Cred ty -> Bool)
-> (Cred ty -> Cred ty -> Bool) -> Eq (Cred ty)
forall ty. Cred ty -> Cred ty -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Cred ty -> Cred ty -> Bool
$c/= :: forall ty. Cred ty -> Cred ty -> Bool
== :: Cred ty -> Cred ty -> Bool
$c== :: forall ty. Cred ty -> Cred ty -> Bool
Eq, Eq (Cred ty)
Eq (Cred ty)
-> (Cred ty -> Cred ty -> Ordering)
-> (Cred ty -> Cred ty -> Bool)
-> (Cred ty -> Cred ty -> Bool)
-> (Cred ty -> Cred ty -> Bool)
-> (Cred ty -> Cred ty -> Bool)
-> (Cred ty -> Cred ty -> Cred ty)
-> (Cred ty -> Cred ty -> Cred ty)
-> Ord (Cred ty)
Cred ty -> Cred ty -> Bool
Cred ty -> Cred ty -> Ordering
Cred ty -> Cred ty -> Cred ty
forall ty. Eq (Cred ty)
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall ty. Cred ty -> Cred ty -> Bool
forall ty. Cred ty -> Cred ty -> Ordering
forall ty. Cred ty -> Cred ty -> Cred ty
min :: Cred ty -> Cred ty -> Cred ty
$cmin :: forall ty. Cred ty -> Cred ty -> Cred ty
max :: Cred ty -> Cred ty -> Cred ty
$cmax :: forall ty. Cred ty -> Cred ty -> Cred ty
>= :: Cred ty -> Cred ty -> Bool
$c>= :: forall ty. Cred ty -> Cred ty -> Bool
> :: Cred ty -> Cred ty -> Bool
$c> :: forall ty. Cred ty -> Cred ty -> Bool
<= :: Cred ty -> Cred ty -> Bool
$c<= :: forall ty. Cred ty -> Cred ty -> Bool
< :: Cred ty -> Cred ty -> Bool
$c< :: forall ty. Cred ty -> Cred ty -> Bool
compare :: Cred ty -> Cred ty -> Ordering
$ccompare :: forall ty. Cred ty -> Cred ty -> Ordering
$cp1Ord :: forall ty. Eq (Cred ty)
Ord, Typeable (Cred ty)
DataType
Constr
Typeable (Cred ty)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Cred ty -> c (Cred ty))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Cred ty))
-> (Cred ty -> Constr)
-> (Cred ty -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Cred ty)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Cred ty)))
-> ((forall b. Data b => b -> b) -> Cred ty -> Cred ty)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Cred ty -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Cred ty -> r)
-> (forall u. (forall d. Data d => d -> u) -> Cred ty -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Cred ty -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Cred ty -> m (Cred ty))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Cred ty -> m (Cred ty))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Cred ty -> m (Cred ty))
-> Data (Cred ty)
Cred ty -> DataType
Cred ty -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Cred ty))
(forall b. Data b => b -> b) -> Cred ty -> Cred ty
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cred ty -> c (Cred ty)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Cred ty)
forall ty. Data ty => Typeable (Cred ty)
forall ty. Data ty => Cred ty -> DataType
forall ty. Data ty => Cred ty -> Constr
forall ty.
Data ty =>
(forall b. Data b => b -> b) -> Cred ty -> Cred ty
forall ty u.
Data ty =>
Int -> (forall d. Data d => d -> u) -> Cred ty -> u
forall ty u.
Data ty =>
(forall d. Data d => d -> u) -> Cred ty -> [u]
forall ty r r'.
Data ty =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Cred ty -> r
forall ty r r'.
Data ty =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Cred ty -> r
forall ty (m :: * -> *).
(Data ty, Monad m) =>
(forall d. Data d => d -> m d) -> Cred ty -> m (Cred ty)
forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Cred ty -> m (Cred ty)
forall ty (c :: * -> *).
Data ty =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Cred ty)
forall ty (c :: * -> *).
Data ty =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cred ty -> c (Cred ty)
forall ty (t :: * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Cred ty))
forall ty (t :: * -> * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Cred ty))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Cred ty -> u
forall u. (forall d. Data d => d -> u) -> Cred ty -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Cred ty -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Cred ty -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Cred ty -> m (Cred ty)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Cred ty -> m (Cred ty)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Cred ty)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cred ty -> c (Cred ty)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Cred ty))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Cred ty))
$cCredAndToken :: Constr
$cCred :: Constr
$tCred :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Cred ty -> m (Cred ty)
$cgmapMo :: forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Cred ty -> m (Cred ty)
gmapMp :: (forall d. Data d => d -> m d) -> Cred ty -> m (Cred ty)
$cgmapMp :: forall ty (m :: * -> *).
(Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Cred ty -> m (Cred ty)
gmapM :: (forall d. Data d => d -> m d) -> Cred ty -> m (Cred ty)
$cgmapM :: forall ty (m :: * -> *).
(Data ty, Monad m) =>
(forall d. Data d => d -> m d) -> Cred ty -> m (Cred ty)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Cred ty -> u
$cgmapQi :: forall ty u.
Data ty =>
Int -> (forall d. Data d => d -> u) -> Cred ty -> u
gmapQ :: (forall d. Data d => d -> u) -> Cred ty -> [u]
$cgmapQ :: forall ty u.
Data ty =>
(forall d. Data d => d -> u) -> Cred ty -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Cred ty -> r
$cgmapQr :: forall ty r r'.
Data ty =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Cred ty -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Cred ty -> r
$cgmapQl :: forall ty r r'.
Data ty =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Cred ty -> r
gmapT :: (forall b. Data b => b -> b) -> Cred ty -> Cred ty
$cgmapT :: forall ty.
Data ty =>
(forall b. Data b => b -> b) -> Cred ty -> Cred ty
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Cred ty))
$cdataCast2 :: forall ty (t :: * -> * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Cred ty))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Cred ty))
$cdataCast1 :: forall ty (t :: * -> *) (c :: * -> *).
(Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Cred ty))
dataTypeOf :: Cred ty -> DataType
$cdataTypeOf :: forall ty. Data ty => Cred ty -> DataType
toConstr :: Cred ty -> Constr
$ctoConstr :: forall ty. Data ty => Cred ty -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Cred ty)
$cgunfold :: forall ty (c :: * -> *).
Data ty =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Cred ty)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cred ty -> c (Cred ty)
$cgfoldl :: forall ty (c :: * -> *).
Data ty =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cred ty -> c (Cred ty)
$cp1Data :: forall ty. Data ty => Typeable (Cred ty)
Data, Typeable )

-- | A lens on the client 'Token' in any 'Cred'.
clientToken :: Functor f => (Token Client -> f (Token Client)) -> Cred ty -> f (Cred ty)
clientToken :: (Token Client -> f (Token Client)) -> Cred ty -> f (Cred ty)
clientToken Token Client -> f (Token Client)
inj (Cred Key
k Key
s) = Token Client -> Cred ty
forall ty ty. Token ty -> Cred ty
fixUp (Token Client -> Cred ty) -> f (Token Client) -> f (Cred ty)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token Client -> f (Token Client)
inj (Key -> Key -> Token Client
forall ty. Key -> Key -> Token ty
Token Key
k Key
s) where
  fixUp :: Token ty -> Cred ty
fixUp (Token Key
k' Key
s') = Key -> Key -> Cred ty
forall ty. Key -> Key -> Cred ty
Cred Key
k' Key
s'
clientToken Token Client -> f (Token Client)
inj (CredAndToken Key
k Key
s Token ty
tok) = Token Client -> Cred ty
forall ty. Token ty -> Cred ty
fixUp (Token Client -> Cred ty) -> f (Token Client) -> f (Cred ty)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token Client -> f (Token Client)
inj (Key -> Key -> Token Client
forall ty. Key -> Key -> Token ty
Token Key
k Key
s) where
  fixUp :: Token ty -> Cred ty
fixUp (Token Key
k' Key
s') = Key -> Key -> Token ty -> Cred ty
forall ty. Key -> Key -> Token ty -> Cred ty
CredAndToken Key
k' Key
s' Token ty
tok
{-# INLINE clientToken #-}

-- | A lens focused on the resource 'Token' when available. The only
-- instances of 'ResourceToken' are 'Temporary' and 'Permanent'. This can
-- be used to upgrade 'Temporary' 'Cred's to 'Permanent' 'Cred's.
resourceToken
  :: (ResourceToken ty, ResourceToken ty', Functor f) =>
     (Token ty -> f (Token ty')) -> Cred ty -> f (Cred ty')
resourceToken :: (Token ty -> f (Token ty')) -> Cred ty -> f (Cred ty')
resourceToken Token ty -> f (Token ty')
inj (CredAndToken Key
k Key
s Token ty
tok) = Key -> Key -> Token ty' -> Cred ty'
forall ty. Key -> Key -> Token ty -> Cred ty
CredAndToken Key
k Key
s (Token ty' -> Cred ty') -> f (Token ty') -> f (Cred ty')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token ty -> f (Token ty')
inj Token ty
tok
{-# INLINE resourceToken #-}

-- | OAuth assumes that, by default, any credential has a resource 'Token' that
-- is by default completely blank. In this way we can talk about the resource
-- 'Token' of even 'Client' 'Cred's.
--
-- >>> getResourceTokenDef (clientCred $ Token "key" "secret")
-- Token "" ""
getResourceTokenDef :: Cred ty -> Token ty
getResourceTokenDef :: Cred ty -> Token ty
getResourceTokenDef Cred{}                 = Key -> Key -> Token ty
forall ty. Key -> Key -> Token ty
Token Key
"" Key
""
getResourceTokenDef (CredAndToken Key
_ Key
_ Token ty
tok) = Token ty
tok

clientCred :: Token Client -> Cred Client
clientCred :: Token Client -> Cred Client
clientCred (Token Key
k Key
s) = Key -> Key -> Cred Client
forall ty. Key -> Key -> Cred ty
Cred Key
k Key
s

temporaryCred :: Token Temporary -> Cred Client -> Cred Temporary
temporaryCred :: Token Temporary -> Cred Client -> Cred Temporary
temporaryCred Token Temporary
tok (Cred         Key
k Key
s  ) = Key -> Key -> Token Temporary -> Cred Temporary
forall ty. Key -> Key -> Token ty -> Cred ty
CredAndToken Key
k Key
s Token Temporary
tok

permanentCred :: Token Permanent -> Cred Client -> Cred Permanent
permanentCred :: Token Permanent -> Cred Client -> Cred Permanent
permanentCred Token Permanent
tok (Cred         Key
k Key
s  ) = Key -> Key -> Token Permanent -> Cred Permanent
forall ty. Key -> Key -> Token ty -> Cred ty
CredAndToken Key
k Key
s Token Permanent
tok

-- | Produce a 'signingKey' from a set of credentials. This is a URL
-- encoded string built from the client secret and the token
-- secret.
--
-- If no token secret exists then the blank string is used.
--
-- prop> \secret -> signingKey (clientCred $ Token "key" secret) == (pctEncode secret <> "&" <> "")
signingKey :: Cred ty -> S.ByteString
signingKey :: Cred ty -> Key
signingKey (Cred Key
_ Key
clSec) = Bool -> Key -> Key
urlEncode Bool
True Key
clSec Key -> Key -> Key
forall a. Semigroup a => a -> a -> a
<> Key
"&" Key -> Key -> Key
forall a. Semigroup a => a -> a -> a
<> Key
""
signingKey (CredAndToken Key
_ Key
clSec (Token Key
_ Key
tkSec)) =
  Key -> Key
pctEncode Key
clSec Key -> Key -> Key
forall a. Semigroup a => a -> a -> a
<> Key
"&" Key -> Key -> Key
forall a. Semigroup a => a -> a -> a
<> Key -> Key
pctEncode Key
tkSec