AuthManager.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

/No description available in the introspection data./
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.Soup.Objects.AuthManager
    ( 

-- * Exported types
    AuthManager(..)                         ,
    IsAuthManager                           ,
    toAuthManager                           ,
    noAuthManager                           ,


 -- * Methods
-- ** clearCachedCredentials #method:clearCachedCredentials#

#if ENABLE_OVERLOADING
    AuthManagerClearCachedCredentialsMethodInfo,
#endif
    authManagerClearCachedCredentials       ,


-- ** useAuth #method:useAuth#

#if ENABLE_OVERLOADING
    AuthManagerUseAuthMethodInfo            ,
#endif
    authManagerUseAuth                      ,




 -- * Signals
-- ** authenticate #signal:authenticate#

    AuthManagerAuthenticateCallback         ,
#if ENABLE_OVERLOADING
    AuthManagerAuthenticateSignalInfo       ,
#endif
    C_AuthManagerAuthenticateCallback       ,
    afterAuthManagerAuthenticate            ,
    genClosure_AuthManagerAuthenticate      ,
    mk_AuthManagerAuthenticateCallback      ,
    noAuthManagerAuthenticateCallback       ,
    onAuthManagerAuthenticate               ,
    wrap_AuthManagerAuthenticateCallback    ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Soup.Interfaces.SessionFeature as Soup.SessionFeature
import {-# SOURCE #-} qualified GI.Soup.Objects.Auth as Soup.Auth
import {-# SOURCE #-} qualified GI.Soup.Objects.Message as Soup.Message
import {-# SOURCE #-} qualified GI.Soup.Structs.URI as Soup.URI

-- | Memory-managed wrapper type.
newtype AuthManager = AuthManager (ManagedPtr AuthManager)
foreign import ccall "soup_auth_manager_get_type"
    c_soup_auth_manager_get_type :: IO GType

instance GObject AuthManager where
    gobjectType = c_soup_auth_manager_get_type
    

-- | Type class for types which can be safely cast to `AuthManager`, for instance with `toAuthManager`.
class (GObject o, O.IsDescendantOf AuthManager o) => IsAuthManager o
instance (GObject o, O.IsDescendantOf AuthManager o) => IsAuthManager o

instance O.HasParentTypes AuthManager
type instance O.ParentTypes AuthManager = '[GObject.Object.Object, Soup.SessionFeature.SessionFeature]

-- | Cast to `AuthManager`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toAuthManager :: (MonadIO m, IsAuthManager o) => o -> m AuthManager
toAuthManager = liftIO . unsafeCastTo AuthManager

-- | A convenience alias for `Nothing` :: `Maybe` `AuthManager`.
noAuthManager :: Maybe AuthManager
noAuthManager = Nothing

#if ENABLE_OVERLOADING
type family ResolveAuthManagerMethod (t :: Symbol) (o :: *) :: * where
    ResolveAuthManagerMethod "addFeature" o = Soup.SessionFeature.SessionFeatureAddFeatureMethodInfo
    ResolveAuthManagerMethod "attach" o = Soup.SessionFeature.SessionFeatureAttachMethodInfo
    ResolveAuthManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveAuthManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveAuthManagerMethod "clearCachedCredentials" o = AuthManagerClearCachedCredentialsMethodInfo
    ResolveAuthManagerMethod "detach" o = Soup.SessionFeature.SessionFeatureDetachMethodInfo
    ResolveAuthManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveAuthManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveAuthManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveAuthManagerMethod "hasFeature" o = Soup.SessionFeature.SessionFeatureHasFeatureMethodInfo
    ResolveAuthManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveAuthManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveAuthManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveAuthManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveAuthManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveAuthManagerMethod "removeFeature" o = Soup.SessionFeature.SessionFeatureRemoveFeatureMethodInfo
    ResolveAuthManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveAuthManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveAuthManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveAuthManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveAuthManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveAuthManagerMethod "useAuth" o = AuthManagerUseAuthMethodInfo
    ResolveAuthManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveAuthManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveAuthManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveAuthManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveAuthManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveAuthManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveAuthManagerMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveAuthManagerMethod t AuthManager, O.MethodInfo info AuthManager p) => OL.IsLabel t (AuthManager -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif

-- signal AuthManager::authenticate
{- |
Emitted when the manager requires the application to
provide authentication credentials.

'GI.Soup.Objects.Session.Session' connects to this signal and emits its own
'GI.Soup.Objects.Session.Session'::@/authenticate/@ signal when it is emitted, so
you shouldn\'t need to use this signal directly.
-}
type AuthManagerAuthenticateCallback =
    Soup.Message.Message
    {- ^ /@msg@/: the 'GI.Soup.Objects.Message.Message' being sent -}
    -> Soup.Auth.Auth
    {- ^ /@auth@/: the 'GI.Soup.Objects.Auth.Auth' to authenticate -}
    -> Bool
    {- ^ /@retrying@/: 'True' if this is the second (or later) attempt -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `AuthManagerAuthenticateCallback`@.
noAuthManagerAuthenticateCallback :: Maybe AuthManagerAuthenticateCallback
noAuthManagerAuthenticateCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_AuthManagerAuthenticateCallback =
    Ptr () ->                               -- object
    Ptr Soup.Message.Message ->
    Ptr Soup.Auth.Auth ->
    CInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_AuthManagerAuthenticateCallback`.
foreign import ccall "wrapper"
    mk_AuthManagerAuthenticateCallback :: C_AuthManagerAuthenticateCallback -> IO (FunPtr C_AuthManagerAuthenticateCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_AuthManagerAuthenticate :: MonadIO m => AuthManagerAuthenticateCallback -> m (GClosure C_AuthManagerAuthenticateCallback)
genClosure_AuthManagerAuthenticate cb = liftIO $ do
    let cb' = wrap_AuthManagerAuthenticateCallback cb
    mk_AuthManagerAuthenticateCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `AuthManagerAuthenticateCallback` into a `C_AuthManagerAuthenticateCallback`.
wrap_AuthManagerAuthenticateCallback ::
    AuthManagerAuthenticateCallback ->
    C_AuthManagerAuthenticateCallback
wrap_AuthManagerAuthenticateCallback _cb _ msg auth retrying _ = do
    msg' <- (newObject Soup.Message.Message) msg
    auth' <- (newObject Soup.Auth.Auth) auth
    let retrying' = (/= 0) retrying
    _cb  msg' auth' retrying'


{- |
Connect a signal handler for the “@authenticate@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' authManager #authenticate callback
@
-}
onAuthManagerAuthenticate :: (IsAuthManager a, MonadIO m) => a -> AuthManagerAuthenticateCallback -> m SignalHandlerId
onAuthManagerAuthenticate obj cb = liftIO $ do
    let cb' = wrap_AuthManagerAuthenticateCallback cb
    cb'' <- mk_AuthManagerAuthenticateCallback cb'
    connectSignalFunPtr obj "authenticate" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@authenticate@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' authManager #authenticate callback
@
-}
afterAuthManagerAuthenticate :: (IsAuthManager a, MonadIO m) => a -> AuthManagerAuthenticateCallback -> m SignalHandlerId
afterAuthManagerAuthenticate obj cb = liftIO $ do
    let cb' = wrap_AuthManagerAuthenticateCallback cb
    cb'' <- mk_AuthManagerAuthenticateCallback cb'
    connectSignalFunPtr obj "authenticate" cb'' SignalConnectAfter


#if ENABLE_OVERLOADING
instance O.HasAttributeList AuthManager
type instance O.AttributeList AuthManager = AuthManagerAttributeList
type AuthManagerAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
#endif

#if ENABLE_OVERLOADING
data AuthManagerAuthenticateSignalInfo
instance SignalInfo AuthManagerAuthenticateSignalInfo where
    type HaskellCallbackType AuthManagerAuthenticateSignalInfo = AuthManagerAuthenticateCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_AuthManagerAuthenticateCallback cb
        cb'' <- mk_AuthManagerAuthenticateCallback cb'
        connectSignalFunPtr obj "authenticate" cb'' connectMode

type instance O.SignalList AuthManager = AuthManagerSignalList
type AuthManagerSignalList = ('[ '("authenticate", AuthManagerAuthenticateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method AuthManager::clear_cached_credentials
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "Soup", name = "AuthManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAuthManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_auth_manager_clear_cached_credentials" soup_auth_manager_clear_cached_credentials :: 
    Ptr AuthManager ->                      -- manager : TInterface (Name {namespace = "Soup", name = "AuthManager"})
    IO ()

{- |
Clear all credentials cached by /@manager@/

/Since: 2.58/
-}
authManagerClearCachedCredentials ::
    (B.CallStack.HasCallStack, MonadIO m, IsAuthManager a) =>
    a
    {- ^ /@manager@/: a 'GI.Soup.Objects.AuthManager.AuthManager' -}
    -> m ()
authManagerClearCachedCredentials manager = liftIO $ do
    manager' <- unsafeManagedPtrCastPtr manager
    soup_auth_manager_clear_cached_credentials manager'
    touchManagedPtr manager
    return ()

#if ENABLE_OVERLOADING
data AuthManagerClearCachedCredentialsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAuthManager a) => O.MethodInfo AuthManagerClearCachedCredentialsMethodInfo a signature where
    overloadedMethod _ = authManagerClearCachedCredentials

#endif

-- method AuthManager::use_auth
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "Soup", name = "AuthManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupAuthManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupURI under which @auth is to be used", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "auth", argType = TInterface (Name {namespace = "Soup", name = "Auth"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #SoupAuth to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_auth_manager_use_auth" soup_auth_manager_use_auth :: 
    Ptr AuthManager ->                      -- manager : TInterface (Name {namespace = "Soup", name = "AuthManager"})
    Ptr Soup.URI.URI ->                     -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    Ptr Soup.Auth.Auth ->                   -- auth : TInterface (Name {namespace = "Soup", name = "Auth"})
    IO ()

{- |
Records that /@auth@/ is to be used under /@uri@/, as though a
WWW-Authenticate header had been received at that URI. This can be
used to \"preload\" /@manager@/\'s auth cache, to avoid an extra HTTP
round trip in the case where you know ahead of time that a 401
response will be returned.

This is only useful for authentication types where the initial
Authorization header does not depend on any additional information
from the server. (Eg, Basic or NTLM, but not Digest.)

/Since: 2.42/
-}
authManagerUseAuth ::
    (B.CallStack.HasCallStack, MonadIO m, IsAuthManager a, Soup.Auth.IsAuth b) =>
    a
    {- ^ /@manager@/: a 'GI.Soup.Objects.AuthManager.AuthManager' -}
    -> Soup.URI.URI
    {- ^ /@uri@/: the 'GI.Soup.Structs.URI.URI' under which /@auth@/ is to be used -}
    -> b
    {- ^ /@auth@/: the 'GI.Soup.Objects.Auth.Auth' to use -}
    -> m ()
authManagerUseAuth manager uri auth = liftIO $ do
    manager' <- unsafeManagedPtrCastPtr manager
    uri' <- unsafeManagedPtrGetPtr uri
    auth' <- unsafeManagedPtrCastPtr auth
    soup_auth_manager_use_auth manager' uri' auth'
    touchManagedPtr manager
    touchManagedPtr uri
    touchManagedPtr auth
    return ()

#if ENABLE_OVERLOADING
data AuthManagerUseAuthMethodInfo
instance (signature ~ (Soup.URI.URI -> b -> m ()), MonadIO m, IsAuthManager a, Soup.Auth.IsAuth b) => O.MethodInfo AuthManagerUseAuthMethodInfo a signature where
    overloadedMethod _ = authManagerUseAuth

#endif