{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}

-- |
-- Module      : GitLab.SystemHooks.GitLabSystemHooks
-- Description : Haskell records corresponding to JSON data from GitLab system hooks
-- Copyright   : (c) Rob Stewart, Heriot-Watt University, 2020
-- License     : BSD3
-- Maintainer  : robstewart57@gmail.com
-- Stability   : stable
module GitLab.SystemHooks.GitLabSystemHooks
  ( receive,
    receiveString,
    tryFire,
  )
where

import qualified Control.Exception as E
import Control.Monad
import Control.Monad.Except
import Control.Monad.IO.Class
import qualified Control.Monad.Reader as MR
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.IO.Utf8 as TIO
import Data.Typeable
import GitLab.SystemHooks.Types
import GitLab.Types
import System.IO.Temp
import System.PosixCompat.Files

-- | Attempts to fire each rule in sequence. Reads the JSON data
-- received from the GitLab server from standard input.
receive :: [Rule] -> GitLab ()
receive :: [Rule] -> GitLab ()
receive [Rule]
rules = do
  Text
eventContent <- IO Text -> GitLabT (ExceptT GitLabError IO) Text
forall a. IO a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO Text
TIO.getContents
  Text -> [Rule] -> GitLab ()
receiveString Text
eventContent [Rule]
rules

-- | Attempts to fire each rule in sequence. Reads the JSON data
-- received from a function argument.
receiveString :: Text -> [Rule] -> GitLab ()
receiveString :: Text -> [Rule] -> GitLab ()
receiveString Text
eventContent [Rule]
rules = do
  -- log all JSON received if AllJSON stated
  Text -> GitLab ()
traceSystemHook Text
eventContent
  -- fire the rules
  [Bool]
didFire <-
    (Rule -> GitLabT (ExceptT GitLabError IO) Bool)
-> [Rule] -> GitLabT (ExceptT GitLabError IO) [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (Text -> Rule -> GitLabT (ExceptT GitLabError IO) Bool
fire Text
eventContent) [Rule]
rules
      GitLabT (ExceptT GitLabError IO) [Bool]
-> (GitLabError -> GitLabT (ExceptT GitLabError IO) [Bool])
-> GitLabT (ExceptT GitLabError IO) [Bool]
forall a.
GitLabT (ExceptT GitLabError IO) a
-> (GitLabError -> GitLabT (ExceptT GitLabError IO) a)
-> GitLabT (ExceptT GitLabError IO) a
forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
`catchError` \(GitLabError Text
e) -> do
        IO [Bool] -> GitLabT (ExceptT GitLabError IO) [Bool]
forall a. IO a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Bool] -> GitLabT (ExceptT GitLabError IO) [Bool])
-> IO [Bool] -> GitLabT (ExceptT GitLabError IO) [Bool]
forall a b. (a -> b) -> a -> b
$ do
          String
fpath <- String -> String -> IO String
writeSystemTempFile String
"gitlab-system-hook-exception-" (Text -> String
T.unpack Text
e)
          IO () -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> FileMode -> IO ()
setFileMode String
fpath FileMode
otherReadMode
          [Bool] -> IO [Bool]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return []

  -- if nothing fired
  Bool -> GitLab () -> GitLab ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ([Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or [Bool]
didFire) (GitLab () -> GitLab ()) -> GitLab () -> GitLab ()
forall a b. (a -> b) -> a -> b
$ do
    GitLabServerConfig
cfg <- (GitLabState -> GitLabServerConfig)
-> GitLabT (ExceptT GitLabError IO) GitLabServerConfig
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
MR.asks GitLabState -> GitLabServerConfig
serverCfg
    -- log the JSON if it was not parsed and NonParsedJSON was stated
    Bool -> GitLab () -> GitLab ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (GitLabServerConfig -> Maybe DebugSystemHooks
debugSystemHooks GitLabServerConfig
cfg Maybe DebugSystemHooks -> Maybe DebugSystemHooks -> Bool
forall a. Eq a => a -> a -> Bool
== DebugSystemHooks -> Maybe DebugSystemHooks
forall a. a -> Maybe a
Just DebugSystemHooks
NonParsedJSON) (GitLab () -> GitLab ()) -> GitLab () -> GitLab ()
forall a b. (a -> b) -> a -> b
$ IO () -> GitLab ()
forall a. IO a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> GitLab ()) -> IO () -> GitLab ()
forall a b. (a -> b) -> a -> b
$ do
      -- no rules fired, was it because the JSON was not parsed?
      Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Text -> Bool
attemptGitLabEventParse Text
eventContent) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
        String
fpath <- String -> String -> IO String
writeSystemTempFile String
"gitlab-system-hook-nonparsed-" (Text -> String
T.unpack Text
eventContent)
        IO () -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> FileMode -> IO ()
setFileMode String
fpath FileMode
otherReadMode
    -- log the JSON if no rules were fired for it and UnprocessedEvents was states
    Bool -> GitLab () -> GitLab ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (GitLabServerConfig -> Maybe DebugSystemHooks
debugSystemHooks GitLabServerConfig
cfg Maybe DebugSystemHooks -> Maybe DebugSystemHooks -> Bool
forall a. Eq a => a -> a -> Bool
== DebugSystemHooks -> Maybe DebugSystemHooks
forall a. a -> Maybe a
Just DebugSystemHooks
UnprocessedEvents) (GitLab () -> GitLab ()) -> GitLab () -> GitLab ()
forall a b. (a -> b) -> a -> b
$ IO () -> GitLab ()
forall a. IO a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> GitLab ()) -> IO () -> GitLab ()
forall a b. (a -> b) -> a -> b
$ do
      String
fpath <- String -> String -> IO String
writeSystemTempFile String
"gitlab-system-hook-unprocessed-" (Text -> String
T.unpack Text
eventContent)
      IO () -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> FileMode -> IO ()
setFileMode String
fpath FileMode
otherReadMode

traceSystemHook :: Text -> GitLab ()
traceSystemHook :: Text -> GitLab ()
traceSystemHook Text
eventContent = do
  GitLabServerConfig
cfg <- (GitLabState -> GitLabServerConfig)
-> GitLabT (ExceptT GitLabError IO) GitLabServerConfig
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
MR.asks GitLabState -> GitLabServerConfig
serverCfg
  IO () -> GitLab ()
forall a. IO a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> GitLab ()) -> IO () -> GitLab ()
forall a b. (a -> b) -> a -> b
$
    IO () -> (ErrorCall -> IO ()) -> IO ()
forall e a. Exception e => IO a -> (e -> IO a) -> IO a
E.catch
      ( Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (GitLabServerConfig -> Maybe DebugSystemHooks
debugSystemHooks GitLabServerConfig
cfg Maybe DebugSystemHooks -> Maybe DebugSystemHooks -> Bool
forall a. Eq a => a -> a -> Bool
== DebugSystemHooks -> Maybe DebugSystemHooks
forall a. a -> Maybe a
Just DebugSystemHooks
AllJSON) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
          String
fpath <- String -> String -> IO String
writeSystemTempFile String
"gitlab-system-hook-" (Text -> String
T.unpack Text
eventContent)
          IO () -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> FileMode -> IO ()
setFileMode String
fpath FileMode
otherReadMode
      )
      -- runGitLabDbg must have been used, which doesn't define a GitLabServerConfig
      (\(ErrorCall
_exception :: E.ErrorCall) -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ())

orElse :: GitLab Bool -> GitLab Bool -> GitLab Bool
orElse :: GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
orElse GitLabT (ExceptT GitLabError IO) Bool
f GitLabT (ExceptT GitLabError IO) Bool
g = do
  Bool
x <- GitLabT (ExceptT GitLabError IO) Bool
f
  if Bool
x
    then Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
    else GitLabT (ExceptT GitLabError IO) Bool
g

fire :: Text -> Rule -> GitLab Bool
fire :: Text -> Rule -> GitLabT (ExceptT GitLabError IO) Bool
fire Text
contents Rule
rule = do
  Bool
result <- Text -> Rule -> GitLabT (ExceptT GitLabError IO) Bool
tryFire Text
contents Rule
rule
  if Bool
result
    then
      ( do
          IO () -> GitLab ()
forall a. IO a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (String -> IO ()
putStrLn (String
"fired: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Rule -> String
labelOf Rule
rule))
          Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
      )
    else Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
  where
    labelOf :: Rule -> String
    labelOf :: Rule -> String
labelOf (Match String
lbl a -> GitLab ()
_) = String
lbl
    labelOf (MatchIf String
lbl a -> GitLabT (ExceptT GitLabError IO) Bool
_ a -> GitLab ()
_) = String
lbl

-- | Try to fire a GitLab rule, returns 'True' if the rule fired and
-- 'False' if it did not fire.
tryFire :: Text -> Rule -> GitLab Bool
tryFire :: Text -> Rule -> GitLabT (ExceptT GitLabError IO) Bool
tryFire Text
contents (Match String
_ a -> GitLab ()
f) = do
  Maybe (ProjectCreate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectCreate -> GitLab ())
-> Maybe ProjectCreate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
    ((ProjectCreate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectCreate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\ProjectCreate
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
    ((a -> GitLab ()) -> Maybe (ProjectCreate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (ProjectCreate -> GitLab ()))
    (Text -> Maybe ProjectCreate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectCreate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (ProjectDestroy -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectDestroy -> GitLab ())
-> Maybe ProjectDestroy
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((ProjectDestroy -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectDestroy -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\ProjectDestroy
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (ProjectDestroy -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (ProjectDestroy -> GitLab ()))
      (Text -> Maybe ProjectDestroy
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectDestroy)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (ProjectRename -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectRename -> GitLab ())
-> Maybe ProjectRename
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((ProjectRename -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectRename -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\ProjectRename
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (ProjectRename -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (ProjectRename -> GitLab ()))
      (Text -> Maybe ProjectRename
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectRename)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (ProjectTransfer -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectTransfer -> GitLab ())
-> Maybe ProjectTransfer
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((ProjectTransfer -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectTransfer -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\ProjectTransfer
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (ProjectTransfer -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (ProjectTransfer -> GitLab ()))
      (Text -> Maybe ProjectTransfer
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectTransfer)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (ProjectUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectUpdate -> GitLab ())
-> Maybe ProjectUpdate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((ProjectUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\ProjectUpdate
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (ProjectUpdate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (ProjectUpdate -> GitLab ()))
      (Text -> Maybe ProjectUpdate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectUpdate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (GroupMemberUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupMemberUpdate -> GitLab ())
-> Maybe GroupMemberUpdate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((GroupMemberUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (GroupMemberUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\GroupMemberUpdate
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (GroupMemberUpdate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (GroupMemberUpdate -> GitLab ()))
      (Text -> Maybe GroupMemberUpdate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupMemberUpdate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserAddToTeam -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserAddToTeam -> GitLab ())
-> Maybe UserAddToTeam
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((UserAddToTeam -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserAddToTeam -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\UserAddToTeam
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (UserAddToTeam -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserAddToTeam -> GitLab ()))
      (Text -> Maybe UserAddToTeam
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserAddToTeam)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserUpdateForTeam -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserUpdateForTeam -> GitLab ())
-> Maybe UserUpdateForTeam
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((UserUpdateForTeam -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (UserUpdateForTeam -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\UserUpdateForTeam
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (UserUpdateForTeam -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserUpdateForTeam -> GitLab ()))
      (Text -> Maybe UserUpdateForTeam
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserUpdateForTeam)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserRemoveFromTeam -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserRemoveFromTeam -> GitLab ())
-> Maybe UserRemoveFromTeam
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((UserRemoveFromTeam -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (UserRemoveFromTeam -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\UserRemoveFromTeam
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (UserRemoveFromTeam -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserRemoveFromTeam -> GitLab ()))
      (Text -> Maybe UserRemoveFromTeam
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserRemoveFromTeam)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserCreate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserCreate -> GitLab ())
-> Maybe UserCreate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((UserCreate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserCreate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\UserCreate
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (UserCreate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserCreate -> GitLab ()))
      (Text -> Maybe UserCreate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserCreate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserRemove -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserRemove -> GitLab ())
-> Maybe UserRemove
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((UserRemove -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserRemove -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\UserRemove
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (UserRemove -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserRemove -> GitLab ()))
      (Text -> Maybe UserRemove
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserRemove)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserFailedLogin -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserFailedLogin -> GitLab ())
-> Maybe UserFailedLogin
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((UserFailedLogin -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserFailedLogin -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\UserFailedLogin
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (UserFailedLogin -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserFailedLogin -> GitLab ()))
      (Text -> Maybe UserFailedLogin
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserFailedLogin)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserRename -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserRename -> GitLab ())
-> Maybe UserRename
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((UserRename -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserRename -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\UserRename
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (UserRename -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserRename -> GitLab ()))
      (Text -> Maybe UserRename
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserRename)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (KeyCreate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (KeyCreate -> GitLab ())
-> Maybe KeyCreate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((KeyCreate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (KeyCreate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\KeyCreate
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (KeyCreate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (KeyCreate -> GitLab ()))
      (Text -> Maybe KeyCreate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe KeyCreate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (KeyRemove -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (KeyRemove -> GitLab ())
-> Maybe KeyRemove
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((KeyRemove -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (KeyRemove -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\KeyRemove
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (KeyRemove -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (KeyRemove -> GitLab ()))
      (Text -> Maybe KeyRemove
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe KeyRemove)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (GroupCreate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupCreate -> GitLab ())
-> Maybe GroupCreate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((GroupCreate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupCreate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\GroupCreate
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (GroupCreate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (GroupCreate -> GitLab ()))
      (Text -> Maybe GroupCreate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupCreate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (GroupRemove -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupRemove -> GitLab ())
-> Maybe GroupRemove
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((GroupRemove -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupRemove -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\GroupRemove
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (GroupRemove -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (GroupRemove -> GitLab ()))
      (Text -> Maybe GroupRemove
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupRemove)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (GroupRenameEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupRenameEvent -> GitLab ())
-> Maybe GroupRenameEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((GroupRenameEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (GroupRenameEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\GroupRenameEvent
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (GroupRenameEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (GroupRenameEvent -> GitLab ()))
      (Text -> Maybe GroupRenameEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupRenameEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (NewGroupMember -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (NewGroupMember -> GitLab ())
-> Maybe NewGroupMember
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((NewGroupMember -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (NewGroupMember -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\NewGroupMember
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (NewGroupMember -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (NewGroupMember -> GitLab ()))
      (Text -> Maybe NewGroupMember
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe NewGroupMember)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (GroupMemberRemove -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupMemberRemove -> GitLab ())
-> Maybe GroupMemberRemove
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((GroupMemberRemove -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (GroupMemberRemove -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\GroupMemberRemove
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (GroupMemberRemove -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (GroupMemberRemove -> GitLab ()))
      (Text -> Maybe GroupMemberRemove
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupMemberRemove)
    -- `orElse` fireIf'
    --   (Just (\_ -> return True))
    --   (cast f :: Maybe (ProjectEvent -> GitLab ()))
    --   (parseEvent contents :: Maybe ProjectEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (Push -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (Push -> GitLab ())
-> Maybe Push
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((Push -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (Push -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\Push
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (Push -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (Push -> GitLab ()))
      (Text -> Maybe Push
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe Push)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (TagPush -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (TagPush -> GitLab ())
-> Maybe TagPush
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((TagPush -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (TagPush -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\TagPush
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (TagPush -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (TagPush -> GitLab ()))
      (Text -> Maybe TagPush
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe TagPush)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (RepositoryUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (RepositoryUpdate -> GitLab ())
-> Maybe RepositoryUpdate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((RepositoryUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (RepositoryUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\RepositoryUpdate
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (RepositoryUpdate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (RepositoryUpdate -> GitLab ()))
      (Text -> Maybe RepositoryUpdate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe RepositoryUpdate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (MergeRequestEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (MergeRequestEvent -> GitLab ())
-> Maybe MergeRequestEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((MergeRequestEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (MergeRequestEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\MergeRequestEvent
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (MergeRequestEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (MergeRequestEvent -> GitLab ()))
      (Text -> Maybe MergeRequestEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe MergeRequestEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (BuildEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (BuildEvent -> GitLab ())
-> Maybe BuildEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((BuildEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (BuildEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\BuildEvent
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (BuildEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (BuildEvent -> GitLab ()))
      (Text -> Maybe BuildEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe BuildEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (PipelineEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (PipelineEvent -> GitLab ())
-> Maybe PipelineEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((PipelineEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (PipelineEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\PipelineEvent
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (PipelineEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (PipelineEvent -> GitLab ()))
      (Text -> Maybe PipelineEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe PipelineEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (IssueEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (IssueEvent -> GitLab ())
-> Maybe IssueEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((IssueEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (IssueEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\IssueEvent
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (IssueEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (IssueEvent -> GitLab ()))
      (Text -> Maybe IssueEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe IssueEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (NoteEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (NoteEvent -> GitLab ())
-> Maybe NoteEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((NoteEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (NoteEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\NoteEvent
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (NoteEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (NoteEvent -> GitLab ()))
      (Text -> Maybe NoteEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe NoteEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (WikiPageEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (WikiPageEvent -> GitLab ())
-> Maybe WikiPageEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((WikiPageEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (WikiPageEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\WikiPageEvent
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (WikiPageEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (WikiPageEvent -> GitLab ()))
      (Text -> Maybe WikiPageEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe WikiPageEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (WorkItemEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (WorkItemEvent -> GitLab ())
-> Maybe WorkItemEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((WorkItemEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (WorkItemEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\WorkItemEvent
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (WorkItemEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (WorkItemEvent -> GitLab ()))
      (Text -> Maybe WorkItemEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe WorkItemEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (EmojiEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (EmojiEvent -> GitLab ())
-> Maybe EmojiEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((EmojiEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (EmojiEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\EmojiEvent
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (EmojiEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (EmojiEvent -> GitLab ()))
      (Text -> Maybe EmojiEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe EmojiEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (AccessTokenEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (AccessTokenEvent -> GitLab ())
-> Maybe AccessTokenEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((AccessTokenEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (AccessTokenEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a. a -> Maybe a
Just (\AccessTokenEvent
_ -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True))
      ((a -> GitLab ()) -> Maybe (AccessTokenEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (AccessTokenEvent -> GitLab ()))
      (Text -> Maybe AccessTokenEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe AccessTokenEvent)
tryFire Text
contents (MatchIf String
_ a -> GitLabT (ExceptT GitLabError IO) Bool
predF a -> GitLab ()
f) = do
  Maybe (ProjectCreate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectCreate -> GitLab ())
-> Maybe ProjectCreate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
    ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectCreate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (ProjectCreate -> GitLab Bool))
    ((a -> GitLab ()) -> Maybe (ProjectCreate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (ProjectCreate -> GitLab ()))
    (Text -> Maybe ProjectCreate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectCreate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (ProjectDestroy -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectDestroy -> GitLab ())
-> Maybe ProjectDestroy
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectDestroy -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (ProjectDestroy -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (ProjectDestroy -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (ProjectDestroy -> GitLab ()))
      (Text -> Maybe ProjectDestroy
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectDestroy)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (ProjectRename -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectRename -> GitLab ())
-> Maybe ProjectRename
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectRename -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (ProjectRename -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (ProjectRename -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (ProjectRename -> GitLab ()))
      (Text -> Maybe ProjectRename
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectRename)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (ProjectTransfer -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectTransfer -> GitLab ())
-> Maybe ProjectTransfer
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectTransfer -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (ProjectTransfer -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (ProjectTransfer -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (ProjectTransfer -> GitLab ()))
      (Text -> Maybe ProjectTransfer
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectTransfer)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (ProjectUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectUpdate -> GitLab ())
-> Maybe ProjectUpdate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (ProjectUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (ProjectUpdate -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (ProjectUpdate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (ProjectUpdate -> GitLab ()))
      (Text -> Maybe ProjectUpdate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectUpdate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (GroupMemberUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupMemberUpdate -> GitLab ())
-> Maybe GroupMemberUpdate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (GroupMemberUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (GroupMemberUpdate -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (GroupMemberUpdate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (GroupMemberUpdate -> GitLab ()))
      (Text -> Maybe GroupMemberUpdate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupMemberUpdate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserAddToTeam -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserAddToTeam -> GitLab ())
-> Maybe UserAddToTeam
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserAddToTeam -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (UserAddToTeam -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (UserAddToTeam -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserAddToTeam -> GitLab ()))
      (Text -> Maybe UserAddToTeam
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserAddToTeam)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserUpdateForTeam -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserUpdateForTeam -> GitLab ())
-> Maybe UserUpdateForTeam
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (UserUpdateForTeam -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (UserUpdateForTeam -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (UserUpdateForTeam -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserUpdateForTeam -> GitLab ()))
      (Text -> Maybe UserUpdateForTeam
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserUpdateForTeam)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserRemoveFromTeam -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserRemoveFromTeam -> GitLab ())
-> Maybe UserRemoveFromTeam
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (UserRemoveFromTeam -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (UserRemoveFromTeam -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (UserRemoveFromTeam -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserRemoveFromTeam -> GitLab ()))
      (Text -> Maybe UserRemoveFromTeam
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserRemoveFromTeam)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserCreate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserCreate -> GitLab ())
-> Maybe UserCreate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserCreate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (UserCreate -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (UserCreate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserCreate -> GitLab ()))
      (Text -> Maybe UserCreate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserCreate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserRemove -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserRemove -> GitLab ())
-> Maybe UserRemove
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserRemove -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (UserRemove -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (UserRemove -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserRemove -> GitLab ()))
      (Text -> Maybe UserRemove
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserRemove)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserFailedLogin -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserFailedLogin -> GitLab ())
-> Maybe UserFailedLogin
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserFailedLogin -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (UserFailedLogin -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (UserFailedLogin -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserFailedLogin -> GitLab ()))
      (Text -> Maybe UserFailedLogin
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserFailedLogin)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (UserRename -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserRename -> GitLab ())
-> Maybe UserRename
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (UserRename -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (UserRename -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (UserRename -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (UserRename -> GitLab ()))
      (Text -> Maybe UserRename
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserRename)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (KeyCreate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (KeyCreate -> GitLab ())
-> Maybe KeyCreate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (KeyCreate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (KeyCreate -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (KeyCreate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (KeyCreate -> GitLab ()))
      (Text -> Maybe KeyCreate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe KeyCreate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (KeyRemove -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (KeyRemove -> GitLab ())
-> Maybe KeyRemove
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (KeyRemove -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (KeyRemove -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (KeyRemove -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (KeyRemove -> GitLab ()))
      (Text -> Maybe KeyRemove
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe KeyRemove)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (GroupCreate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupCreate -> GitLab ())
-> Maybe GroupCreate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupCreate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (GroupCreate -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (GroupCreate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (GroupCreate -> GitLab ()))
      (Text -> Maybe GroupCreate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupCreate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (GroupRemove -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupRemove -> GitLab ())
-> Maybe GroupRemove
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupRemove -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (GroupRemove -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (GroupRemove -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (GroupRemove -> GitLab ()))
      (Text -> Maybe GroupRemove
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupRemove)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (GroupRenameEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupRenameEvent -> GitLab ())
-> Maybe GroupRenameEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (GroupRenameEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (GroupRenameEvent -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (GroupRenameEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (GroupRenameEvent -> GitLab ()))
      (Text -> Maybe GroupRenameEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupRenameEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (NewGroupMember -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (NewGroupMember -> GitLab ())
-> Maybe NewGroupMember
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (NewGroupMember -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (NewGroupMember -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (NewGroupMember -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (NewGroupMember -> GitLab ()))
      (Text -> Maybe NewGroupMember
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe NewGroupMember)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (GroupMemberRemove -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (GroupMemberRemove -> GitLab ())
-> Maybe GroupMemberRemove
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (GroupMemberRemove -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (GroupMemberRemove -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (GroupMemberRemove -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (GroupMemberRemove -> GitLab ()))
      (Text -> Maybe GroupMemberRemove
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupMemberRemove)
    -- `orElse` fireIf'
    --   (cast predF :: Maybe (ProjectEvent -> GitLab Bool))
    --   (cast f :: Maybe (ProjectEvent -> GitLab ()))
    --   (parseEvent contents :: Maybe ProjectEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (Push -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (Push -> GitLab ())
-> Maybe Push
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (Push -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (Push -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (Push -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (Push -> GitLab ()))
      (Text -> Maybe Push
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe Push)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (TagPush -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (TagPush -> GitLab ())
-> Maybe TagPush
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (TagPush -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (TagPush -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (TagPush -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (TagPush -> GitLab ()))
      (Text -> Maybe TagPush
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe TagPush)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (RepositoryUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (RepositoryUpdate -> GitLab ())
-> Maybe RepositoryUpdate
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (RepositoryUpdate -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (RepositoryUpdate -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (RepositoryUpdate -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (RepositoryUpdate -> GitLab ()))
      (Text -> Maybe RepositoryUpdate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe RepositoryUpdate)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (MergeRequestEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (MergeRequestEvent -> GitLab ())
-> Maybe MergeRequestEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (MergeRequestEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (MergeRequestEvent -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (MergeRequestEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (MergeRequestEvent -> GitLab ()))
      (Text -> Maybe MergeRequestEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe MergeRequestEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (BuildEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (BuildEvent -> GitLab ())
-> Maybe BuildEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (BuildEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (BuildEvent -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (BuildEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (BuildEvent -> GitLab ()))
      (Text -> Maybe BuildEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe BuildEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (PipelineEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (PipelineEvent -> GitLab ())
-> Maybe PipelineEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (PipelineEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (PipelineEvent -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (PipelineEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (PipelineEvent -> GitLab ()))
      (Text -> Maybe PipelineEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe PipelineEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (IssueEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (IssueEvent -> GitLab ())
-> Maybe IssueEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (IssueEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (IssueEvent -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (IssueEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (IssueEvent -> GitLab ()))
      (Text -> Maybe IssueEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe IssueEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (NoteEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (NoteEvent -> GitLab ())
-> Maybe NoteEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (NoteEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (NoteEvent -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (NoteEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (NoteEvent -> GitLab ()))
      (Text -> Maybe NoteEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe NoteEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (WikiPageEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (WikiPageEvent -> GitLab ())
-> Maybe WikiPageEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (WikiPageEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (WikiPageEvent -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (WikiPageEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (WikiPageEvent -> GitLab ()))
      (Text -> Maybe WikiPageEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe WikiPageEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (WorkItemEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (WorkItemEvent -> GitLab ())
-> Maybe WorkItemEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (WorkItemEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (WorkItemEvent -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (WorkItemEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (WorkItemEvent -> GitLab ()))
      (Text -> Maybe WorkItemEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe WorkItemEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (EmojiEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (EmojiEvent -> GitLab ())
-> Maybe EmojiEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (EmojiEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (EmojiEvent -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (EmojiEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (EmojiEvent -> GitLab ()))
      (Text -> Maybe EmojiEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe EmojiEvent)
    GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
-> GitLabT (ExceptT GitLabError IO) Bool
`orElse` Maybe (AccessTokenEvent -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (AccessTokenEvent -> GitLab ())
-> Maybe AccessTokenEvent
-> GitLabT (ExceptT GitLabError IO) Bool
forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf'
      ((a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe
     (AccessTokenEvent -> GitLabT (ExceptT GitLabError IO) Bool)
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLabT (ExceptT GitLabError IO) Bool
predF :: Maybe (AccessTokenEvent -> GitLab Bool))
      ((a -> GitLab ()) -> Maybe (AccessTokenEvent -> GitLab ())
forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast a -> GitLab ()
f :: Maybe (AccessTokenEvent -> GitLab ()))
      (Text -> Maybe AccessTokenEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe AccessTokenEvent)

fireIf' :: (Typeable a, Show a) => Maybe (a -> GitLab Bool) -> Maybe (a -> GitLab ()) -> Maybe a -> GitLab Bool
fireIf' :: forall a.
(Typeable a, Show a) =>
Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
-> Maybe (a -> GitLab ())
-> Maybe a
-> GitLabT (ExceptT GitLabError IO) Bool
fireIf' Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
castPred Maybe (a -> GitLab ())
castF Maybe a
parsed = do
  case Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
castPred of
    Maybe (a -> GitLabT (ExceptT GitLabError IO) Bool)
Nothing -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
    Just a -> GitLabT (ExceptT GitLabError IO) Bool
pred' ->
      case Maybe (a -> GitLab ())
castF of
        Maybe (a -> GitLab ())
Nothing -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
        Just a -> GitLab ()
f' ->
          case Maybe a
parsed of
            Maybe a
Nothing -> Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
            Just a
parsed' -> do
              Bool
testPred <- a -> GitLabT (ExceptT GitLabError IO) Bool
pred' a
parsed'
              if Bool
testPred
                then do
                  a -> GitLab ()
f' a
parsed'
                  Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
                else Bool -> GitLabT (ExceptT GitLabError IO) Bool
forall a. a -> GitLabT (ExceptT GitLabError IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False

-- | returns 'True' if at least on parsing attemps of the JSON is successful
attemptGitLabEventParse :: T.Text -> Bool
attemptGitLabEventParse :: Text -> Bool
attemptGitLabEventParse Text
contents =
  -- note: this needs refactoring to be less verbose
  case Text -> Maybe ProjectCreate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectCreate of
    Just ProjectCreate
_ -> Bool
True
    Maybe ProjectCreate
Nothing ->
      case Text -> Maybe ProjectDestroy
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectDestroy of
        Just ProjectDestroy
_ -> Bool
True
        Maybe ProjectDestroy
Nothing ->
          case Text -> Maybe ProjectRename
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectRename of
            Just ProjectRename
_ -> Bool
True
            Maybe ProjectRename
Nothing ->
              case Text -> Maybe ProjectTransfer
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectTransfer of
                Just ProjectTransfer
_ -> Bool
True
                Maybe ProjectTransfer
Nothing ->
                  case Text -> Maybe ProjectUpdate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe ProjectUpdate of
                    Just ProjectUpdate
_ -> Bool
True
                    Maybe ProjectUpdate
Nothing ->
                      case Text -> Maybe GroupMemberUpdate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupMemberUpdate of
                        Just GroupMemberUpdate
_ -> Bool
True
                        Maybe GroupMemberUpdate
Nothing ->
                          case Text -> Maybe UserAddToTeam
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserAddToTeam of
                            Just UserAddToTeam
_ -> Bool
True
                            Maybe UserAddToTeam
Nothing ->
                              case Text -> Maybe UserUpdateForTeam
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserUpdateForTeam of
                                Just UserUpdateForTeam
_ -> Bool
True
                                Maybe UserUpdateForTeam
Nothing ->
                                  case Text -> Maybe UserRemoveFromTeam
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserRemoveFromTeam of
                                    Just UserRemoveFromTeam
_ -> Bool
True
                                    Maybe UserRemoveFromTeam
Nothing ->
                                      case Text -> Maybe UserCreate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserCreate of
                                        Just UserCreate
_ -> Bool
True
                                        Maybe UserCreate
Nothing ->
                                          case Text -> Maybe UserRemove
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserRemove of
                                            Just UserRemove
_ -> Bool
True
                                            Maybe UserRemove
Nothing ->
                                              case Text -> Maybe UserFailedLogin
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserFailedLogin of
                                                Just UserFailedLogin
_ -> Bool
True
                                                Maybe UserFailedLogin
Nothing ->
                                                  case Text -> Maybe UserRename
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe UserRename of
                                                    Just UserRename
_ -> Bool
True
                                                    Maybe UserRename
Nothing ->
                                                      case Text -> Maybe KeyCreate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe KeyCreate of
                                                        Just KeyCreate
_ -> Bool
True
                                                        Maybe KeyCreate
Nothing ->
                                                          case Text -> Maybe KeyRemove
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe KeyRemove of
                                                            Just KeyRemove
_ -> Bool
True
                                                            Maybe KeyRemove
Nothing ->
                                                              case Text -> Maybe GroupCreate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupCreate of
                                                                Just GroupCreate
_ -> Bool
True
                                                                Maybe GroupCreate
Nothing ->
                                                                  case Text -> Maybe GroupRemove
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupRemove of
                                                                    Just GroupRemove
_ -> Bool
True
                                                                    Maybe GroupRemove
Nothing ->
                                                                      case Text -> Maybe GroupRenameEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupRenameEvent of
                                                                        Just GroupRenameEvent
_ -> Bool
True
                                                                        Maybe GroupRenameEvent
Nothing ->
                                                                          case Text -> Maybe NewGroupMember
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe NewGroupMember of
                                                                            Just NewGroupMember
_ -> Bool
True
                                                                            Maybe NewGroupMember
Nothing ->
                                                                              case Text -> Maybe GroupMemberRemove
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe GroupMemberRemove of
                                                                                Just GroupMemberRemove
_ -> Bool
True
                                                                                Maybe GroupMemberRemove
Nothing ->
                                                                                  case Text -> Maybe Push
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe Push of
                                                                                    Just Push
_ -> Bool
True
                                                                                    Maybe Push
Nothing ->
                                                                                      case Text -> Maybe TagPush
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe TagPush of
                                                                                        Just TagPush
_ -> Bool
True
                                                                                        Maybe TagPush
Nothing ->
                                                                                          case Text -> Maybe RepositoryUpdate
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe RepositoryUpdate of
                                                                                            Just RepositoryUpdate
_ -> Bool
True
                                                                                            Maybe RepositoryUpdate
Nothing ->
                                                                                              case Text -> Maybe MergeRequestEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe MergeRequestEvent of
                                                                                                Just MergeRequestEvent
_ -> Bool
True
                                                                                                Maybe MergeRequestEvent
Nothing ->
                                                                                                  case Text -> Maybe BuildEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe BuildEvent of
                                                                                                    Just BuildEvent
_ -> Bool
True
                                                                                                    Maybe BuildEvent
Nothing ->
                                                                                                      case Text -> Maybe PipelineEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe PipelineEvent of
                                                                                                        Just PipelineEvent
_ -> Bool
True
                                                                                                        Maybe PipelineEvent
Nothing ->
                                                                                                          case Text -> Maybe IssueEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe IssueEvent of
                                                                                                            Just IssueEvent
_ -> Bool
True
                                                                                                            Maybe IssueEvent
Nothing ->
                                                                                                              case Text -> Maybe NoteEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe NoteEvent of
                                                                                                                Just NoteEvent
_ -> Bool
True
                                                                                                                Maybe NoteEvent
Nothing ->
                                                                                                                  case Text -> Maybe WikiPageEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe WikiPageEvent of
                                                                                                                    Just WikiPageEvent
_ -> Bool
True
                                                                                                                    Maybe WikiPageEvent
Nothing ->
                                                                                                                      case Text -> Maybe WorkItemEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe WorkItemEvent of
                                                                                                                        Just WorkItemEvent
_ -> Bool
True
                                                                                                                        Maybe WorkItemEvent
Nothing ->
                                                                                                                          case Text -> Maybe EmojiEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe EmojiEvent of
                                                                                                                            Just EmojiEvent
_ -> Bool
True
                                                                                                                            Maybe EmojiEvent
Nothing ->
                                                                                                                              case Text -> Maybe AccessTokenEvent
forall a. FromJSON a => Text -> Maybe a
parseEvent Text
contents :: Maybe AccessTokenEvent of
                                                                                                                                Just AccessTokenEvent
_ -> Bool
True
                                                                                                                                Maybe AccessTokenEvent
Nothing -> Bool
False