{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}

-- | The zuul status data type
module Zuul.Status
  ( -- * Status data types
    JobStatus (..),
    Change (..),
    Changes (..),
    ChangeQueue (..),
    Pipeline (..),
    Status (..),

    -- * Convenient functions
    pipelineChanges,
    liveChanges,
    changeJobUuid,
  )
where

import Control.Monad (guard)
import Data.Aeson (FromJSON (..), ToJSON (..))
import Data.Maybe (fromJust, isJust)
import Data.Text (Text)
import GHC.Generics (Generic)
import Zuul.Aeson (zuulParseJSON, zuulToJSON)

data JobStatus = JobStatus
  { JobStatus -> Text
jobName :: Text,
    JobStatus -> Maybe Text
jobUuid :: Maybe Text,
    JobStatus -> Maybe Text
jobResult :: Maybe Text
  }
  deriving (Int -> JobStatus -> ShowS
[JobStatus] -> ShowS
JobStatus -> String
(Int -> JobStatus -> ShowS)
-> (JobStatus -> String)
-> ([JobStatus] -> ShowS)
-> Show JobStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JobStatus] -> ShowS
$cshowList :: [JobStatus] -> ShowS
show :: JobStatus -> String
$cshow :: JobStatus -> String
showsPrec :: Int -> JobStatus -> ShowS
$cshowsPrec :: Int -> JobStatus -> ShowS
Show, JobStatus -> JobStatus -> Bool
(JobStatus -> JobStatus -> Bool)
-> (JobStatus -> JobStatus -> Bool) -> Eq JobStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JobStatus -> JobStatus -> Bool
$c/= :: JobStatus -> JobStatus -> Bool
== :: JobStatus -> JobStatus -> Bool
$c== :: JobStatus -> JobStatus -> Bool
Eq, Eq JobStatus
Eq JobStatus
-> (JobStatus -> JobStatus -> Ordering)
-> (JobStatus -> JobStatus -> Bool)
-> (JobStatus -> JobStatus -> Bool)
-> (JobStatus -> JobStatus -> Bool)
-> (JobStatus -> JobStatus -> Bool)
-> (JobStatus -> JobStatus -> JobStatus)
-> (JobStatus -> JobStatus -> JobStatus)
-> Ord JobStatus
JobStatus -> JobStatus -> Bool
JobStatus -> JobStatus -> Ordering
JobStatus -> JobStatus -> JobStatus
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: JobStatus -> JobStatus -> JobStatus
$cmin :: JobStatus -> JobStatus -> JobStatus
max :: JobStatus -> JobStatus -> JobStatus
$cmax :: JobStatus -> JobStatus -> JobStatus
>= :: JobStatus -> JobStatus -> Bool
$c>= :: JobStatus -> JobStatus -> Bool
> :: JobStatus -> JobStatus -> Bool
$c> :: JobStatus -> JobStatus -> Bool
<= :: JobStatus -> JobStatus -> Bool
$c<= :: JobStatus -> JobStatus -> Bool
< :: JobStatus -> JobStatus -> Bool
$c< :: JobStatus -> JobStatus -> Bool
compare :: JobStatus -> JobStatus -> Ordering
$ccompare :: JobStatus -> JobStatus -> Ordering
$cp1Ord :: Eq JobStatus
Ord, (forall x. JobStatus -> Rep JobStatus x)
-> (forall x. Rep JobStatus x -> JobStatus) -> Generic JobStatus
forall x. Rep JobStatus x -> JobStatus
forall x. JobStatus -> Rep JobStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep JobStatus x -> JobStatus
$cfrom :: forall x. JobStatus -> Rep JobStatus x
Generic)

instance FromJSON JobStatus where
  parseJSON :: Value -> Parser JobStatus
parseJSON = Text -> Value -> Parser JobStatus
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Text -> Value -> Parser a
zuulParseJSON Text
"job"

instance ToJSON JobStatus where
  toJSON :: JobStatus -> Value
toJSON = Text -> JobStatus -> Value
forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Text -> a -> Value
zuulToJSON Text
"job"

data Change = Change
  { Change -> Maybe Text
changeId :: Maybe Text,
    Change -> Text
changeRef :: Text,
    Change -> Text
changeProject :: Text,
    Change -> Bool
changeLive :: Bool,
    Change -> Bool
changeActive :: Bool,
    Change -> [JobStatus]
changeJobs :: [JobStatus]
  }
  deriving (Int -> Change -> ShowS
[Change] -> ShowS
Change -> String
(Int -> Change -> ShowS)
-> (Change -> String) -> ([Change] -> ShowS) -> Show Change
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Change] -> ShowS
$cshowList :: [Change] -> ShowS
show :: Change -> String
$cshow :: Change -> String
showsPrec :: Int -> Change -> ShowS
$cshowsPrec :: Int -> Change -> ShowS
Show, Change -> Change -> Bool
(Change -> Change -> Bool)
-> (Change -> Change -> Bool) -> Eq Change
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Change -> Change -> Bool
$c/= :: Change -> Change -> Bool
== :: Change -> Change -> Bool
$c== :: Change -> Change -> Bool
Eq, Eq Change
Eq Change
-> (Change -> Change -> Ordering)
-> (Change -> Change -> Bool)
-> (Change -> Change -> Bool)
-> (Change -> Change -> Bool)
-> (Change -> Change -> Bool)
-> (Change -> Change -> Change)
-> (Change -> Change -> Change)
-> Ord Change
Change -> Change -> Bool
Change -> Change -> Ordering
Change -> Change -> Change
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Change -> Change -> Change
$cmin :: Change -> Change -> Change
max :: Change -> Change -> Change
$cmax :: Change -> Change -> Change
>= :: Change -> Change -> Bool
$c>= :: Change -> Change -> Bool
> :: Change -> Change -> Bool
$c> :: Change -> Change -> Bool
<= :: Change -> Change -> Bool
$c<= :: Change -> Change -> Bool
< :: Change -> Change -> Bool
$c< :: Change -> Change -> Bool
compare :: Change -> Change -> Ordering
$ccompare :: Change -> Change -> Ordering
$cp1Ord :: Eq Change
Ord, (forall x. Change -> Rep Change x)
-> (forall x. Rep Change x -> Change) -> Generic Change
forall x. Rep Change x -> Change
forall x. Change -> Rep Change x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Change x -> Change
$cfrom :: forall x. Change -> Rep Change x
Generic)

instance FromJSON Change where
  parseJSON :: Value -> Parser Change
parseJSON = Text -> Value -> Parser Change
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Text -> Value -> Parser a
zuulParseJSON Text
"change"

instance ToJSON Change where
  toJSON :: Change -> Value
toJSON = Text -> Change -> Value
forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Text -> a -> Value
zuulToJSON Text
"change"

newtype Changes = Changes [Change]
  deriving (Int -> Changes -> ShowS
[Changes] -> ShowS
Changes -> String
(Int -> Changes -> ShowS)
-> (Changes -> String) -> ([Changes] -> ShowS) -> Show Changes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Changes] -> ShowS
$cshowList :: [Changes] -> ShowS
show :: Changes -> String
$cshow :: Changes -> String
showsPrec :: Int -> Changes -> ShowS
$cshowsPrec :: Int -> Changes -> ShowS
Show, Changes -> Changes -> Bool
(Changes -> Changes -> Bool)
-> (Changes -> Changes -> Bool) -> Eq Changes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Changes -> Changes -> Bool
$c/= :: Changes -> Changes -> Bool
== :: Changes -> Changes -> Bool
$c== :: Changes -> Changes -> Bool
Eq, Eq Changes
Eq Changes
-> (Changes -> Changes -> Ordering)
-> (Changes -> Changes -> Bool)
-> (Changes -> Changes -> Bool)
-> (Changes -> Changes -> Bool)
-> (Changes -> Changes -> Bool)
-> (Changes -> Changes -> Changes)
-> (Changes -> Changes -> Changes)
-> Ord Changes
Changes -> Changes -> Bool
Changes -> Changes -> Ordering
Changes -> Changes -> Changes
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Changes -> Changes -> Changes
$cmin :: Changes -> Changes -> Changes
max :: Changes -> Changes -> Changes
$cmax :: Changes -> Changes -> Changes
>= :: Changes -> Changes -> Bool
$c>= :: Changes -> Changes -> Bool
> :: Changes -> Changes -> Bool
$c> :: Changes -> Changes -> Bool
<= :: Changes -> Changes -> Bool
$c<= :: Changes -> Changes -> Bool
< :: Changes -> Changes -> Bool
$c< :: Changes -> Changes -> Bool
compare :: Changes -> Changes -> Ordering
$ccompare :: Changes -> Changes -> Ordering
$cp1Ord :: Eq Changes
Ord, (forall x. Changes -> Rep Changes x)
-> (forall x. Rep Changes x -> Changes) -> Generic Changes
forall x. Rep Changes x -> Changes
forall x. Changes -> Rep Changes x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Changes x -> Changes
$cfrom :: forall x. Changes -> Rep Changes x
Generic, Value -> Parser [Changes]
Value -> Parser Changes
(Value -> Parser Changes)
-> (Value -> Parser [Changes]) -> FromJSON Changes
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [Changes]
$cparseJSONList :: Value -> Parser [Changes]
parseJSON :: Value -> Parser Changes
$cparseJSON :: Value -> Parser Changes
FromJSON, [Changes] -> Encoding
[Changes] -> Value
Changes -> Encoding
Changes -> Value
(Changes -> Value)
-> (Changes -> Encoding)
-> ([Changes] -> Value)
-> ([Changes] -> Encoding)
-> ToJSON Changes
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [Changes] -> Encoding
$ctoEncodingList :: [Changes] -> Encoding
toJSONList :: [Changes] -> Value
$ctoJSONList :: [Changes] -> Value
toEncoding :: Changes -> Encoding
$ctoEncoding :: Changes -> Encoding
toJSON :: Changes -> Value
$ctoJSON :: Changes -> Value
ToJSON)

data ChangeQueue = ChangeQueue
  { ChangeQueue -> Text
changeQueueName :: Text,
    ChangeQueue -> [Changes]
changeQueueHeads :: [Changes]
  }
  deriving (Int -> ChangeQueue -> ShowS
[ChangeQueue] -> ShowS
ChangeQueue -> String
(Int -> ChangeQueue -> ShowS)
-> (ChangeQueue -> String)
-> ([ChangeQueue] -> ShowS)
-> Show ChangeQueue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ChangeQueue] -> ShowS
$cshowList :: [ChangeQueue] -> ShowS
show :: ChangeQueue -> String
$cshow :: ChangeQueue -> String
showsPrec :: Int -> ChangeQueue -> ShowS
$cshowsPrec :: Int -> ChangeQueue -> ShowS
Show, ChangeQueue -> ChangeQueue -> Bool
(ChangeQueue -> ChangeQueue -> Bool)
-> (ChangeQueue -> ChangeQueue -> Bool) -> Eq ChangeQueue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ChangeQueue -> ChangeQueue -> Bool
$c/= :: ChangeQueue -> ChangeQueue -> Bool
== :: ChangeQueue -> ChangeQueue -> Bool
$c== :: ChangeQueue -> ChangeQueue -> Bool
Eq, Eq ChangeQueue
Eq ChangeQueue
-> (ChangeQueue -> ChangeQueue -> Ordering)
-> (ChangeQueue -> ChangeQueue -> Bool)
-> (ChangeQueue -> ChangeQueue -> Bool)
-> (ChangeQueue -> ChangeQueue -> Bool)
-> (ChangeQueue -> ChangeQueue -> Bool)
-> (ChangeQueue -> ChangeQueue -> ChangeQueue)
-> (ChangeQueue -> ChangeQueue -> ChangeQueue)
-> Ord ChangeQueue
ChangeQueue -> ChangeQueue -> Bool
ChangeQueue -> ChangeQueue -> Ordering
ChangeQueue -> ChangeQueue -> ChangeQueue
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ChangeQueue -> ChangeQueue -> ChangeQueue
$cmin :: ChangeQueue -> ChangeQueue -> ChangeQueue
max :: ChangeQueue -> ChangeQueue -> ChangeQueue
$cmax :: ChangeQueue -> ChangeQueue -> ChangeQueue
>= :: ChangeQueue -> ChangeQueue -> Bool
$c>= :: ChangeQueue -> ChangeQueue -> Bool
> :: ChangeQueue -> ChangeQueue -> Bool
$c> :: ChangeQueue -> ChangeQueue -> Bool
<= :: ChangeQueue -> ChangeQueue -> Bool
$c<= :: ChangeQueue -> ChangeQueue -> Bool
< :: ChangeQueue -> ChangeQueue -> Bool
$c< :: ChangeQueue -> ChangeQueue -> Bool
compare :: ChangeQueue -> ChangeQueue -> Ordering
$ccompare :: ChangeQueue -> ChangeQueue -> Ordering
$cp1Ord :: Eq ChangeQueue
Ord, (forall x. ChangeQueue -> Rep ChangeQueue x)
-> (forall x. Rep ChangeQueue x -> ChangeQueue)
-> Generic ChangeQueue
forall x. Rep ChangeQueue x -> ChangeQueue
forall x. ChangeQueue -> Rep ChangeQueue x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ChangeQueue x -> ChangeQueue
$cfrom :: forall x. ChangeQueue -> Rep ChangeQueue x
Generic)

instance FromJSON ChangeQueue where
  parseJSON :: Value -> Parser ChangeQueue
parseJSON = Text -> Value -> Parser ChangeQueue
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Text -> Value -> Parser a
zuulParseJSON Text
"changeQueue"

instance ToJSON ChangeQueue where
  toJSON :: ChangeQueue -> Value
toJSON = Text -> ChangeQueue -> Value
forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Text -> a -> Value
zuulToJSON Text
"changeQueue"

data Pipeline = Pipeline
  { Pipeline -> Text
pipelineName :: Text,
    Pipeline -> [ChangeQueue]
pipelineChangeQueues :: [ChangeQueue]
  }
  deriving (Int -> Pipeline -> ShowS
[Pipeline] -> ShowS
Pipeline -> String
(Int -> Pipeline -> ShowS)
-> (Pipeline -> String) -> ([Pipeline] -> ShowS) -> Show Pipeline
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Pipeline] -> ShowS
$cshowList :: [Pipeline] -> ShowS
show :: Pipeline -> String
$cshow :: Pipeline -> String
showsPrec :: Int -> Pipeline -> ShowS
$cshowsPrec :: Int -> Pipeline -> ShowS
Show, Pipeline -> Pipeline -> Bool
(Pipeline -> Pipeline -> Bool)
-> (Pipeline -> Pipeline -> Bool) -> Eq Pipeline
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pipeline -> Pipeline -> Bool
$c/= :: Pipeline -> Pipeline -> Bool
== :: Pipeline -> Pipeline -> Bool
$c== :: Pipeline -> Pipeline -> Bool
Eq, Eq Pipeline
Eq Pipeline
-> (Pipeline -> Pipeline -> Ordering)
-> (Pipeline -> Pipeline -> Bool)
-> (Pipeline -> Pipeline -> Bool)
-> (Pipeline -> Pipeline -> Bool)
-> (Pipeline -> Pipeline -> Bool)
-> (Pipeline -> Pipeline -> Pipeline)
-> (Pipeline -> Pipeline -> Pipeline)
-> Ord Pipeline
Pipeline -> Pipeline -> Bool
Pipeline -> Pipeline -> Ordering
Pipeline -> Pipeline -> Pipeline
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Pipeline -> Pipeline -> Pipeline
$cmin :: Pipeline -> Pipeline -> Pipeline
max :: Pipeline -> Pipeline -> Pipeline
$cmax :: Pipeline -> Pipeline -> Pipeline
>= :: Pipeline -> Pipeline -> Bool
$c>= :: Pipeline -> Pipeline -> Bool
> :: Pipeline -> Pipeline -> Bool
$c> :: Pipeline -> Pipeline -> Bool
<= :: Pipeline -> Pipeline -> Bool
$c<= :: Pipeline -> Pipeline -> Bool
< :: Pipeline -> Pipeline -> Bool
$c< :: Pipeline -> Pipeline -> Bool
compare :: Pipeline -> Pipeline -> Ordering
$ccompare :: Pipeline -> Pipeline -> Ordering
$cp1Ord :: Eq Pipeline
Ord, (forall x. Pipeline -> Rep Pipeline x)
-> (forall x. Rep Pipeline x -> Pipeline) -> Generic Pipeline
forall x. Rep Pipeline x -> Pipeline
forall x. Pipeline -> Rep Pipeline x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Pipeline x -> Pipeline
$cfrom :: forall x. Pipeline -> Rep Pipeline x
Generic)

instance FromJSON Pipeline where
  parseJSON :: Value -> Parser Pipeline
parseJSON = Text -> Value -> Parser Pipeline
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Text -> Value -> Parser a
zuulParseJSON Text
"pipeline"

instance ToJSON Pipeline where
  toJSON :: Pipeline -> Value
toJSON = Text -> Pipeline -> Value
forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Text -> a -> Value
zuulToJSON Text
"pipeline"

data Status = Status
  { Status -> Text
statusZuulVersion :: Text,
    Status -> [Pipeline]
statusPipelines :: [Pipeline]
  }
  deriving (Int -> Status -> ShowS
[Status] -> ShowS
Status -> String
(Int -> Status -> ShowS)
-> (Status -> String) -> ([Status] -> ShowS) -> Show Status
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Status] -> ShowS
$cshowList :: [Status] -> ShowS
show :: Status -> String
$cshow :: Status -> String
showsPrec :: Int -> Status -> ShowS
$cshowsPrec :: Int -> Status -> ShowS
Show, Status -> Status -> Bool
(Status -> Status -> Bool)
-> (Status -> Status -> Bool) -> Eq Status
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Status -> Status -> Bool
$c/= :: Status -> Status -> Bool
== :: Status -> Status -> Bool
$c== :: Status -> Status -> Bool
Eq, Eq Status
Eq Status
-> (Status -> Status -> Ordering)
-> (Status -> Status -> Bool)
-> (Status -> Status -> Bool)
-> (Status -> Status -> Bool)
-> (Status -> Status -> Bool)
-> (Status -> Status -> Status)
-> (Status -> Status -> Status)
-> Ord Status
Status -> Status -> Bool
Status -> Status -> Ordering
Status -> Status -> Status
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Status -> Status -> Status
$cmin :: Status -> Status -> Status
max :: Status -> Status -> Status
$cmax :: Status -> Status -> Status
>= :: Status -> Status -> Bool
$c>= :: Status -> Status -> Bool
> :: Status -> Status -> Bool
$c> :: Status -> Status -> Bool
<= :: Status -> Status -> Bool
$c<= :: Status -> Status -> Bool
< :: Status -> Status -> Bool
$c< :: Status -> Status -> Bool
compare :: Status -> Status -> Ordering
$ccompare :: Status -> Status -> Ordering
$cp1Ord :: Eq Status
Ord, (forall x. Status -> Rep Status x)
-> (forall x. Rep Status x -> Status) -> Generic Status
forall x. Rep Status x -> Status
forall x. Status -> Rep Status x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Status x -> Status
$cfrom :: forall x. Status -> Rep Status x
Generic)

instance FromJSON Status where
  parseJSON :: Value -> Parser Status
parseJSON = Text -> Value -> Parser Status
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Text -> Value -> Parser a
zuulParseJSON Text
"status"

instance ToJSON Status where
  toJSON :: Status -> Value
toJSON = Text -> Status -> Value
forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Text -> a -> Value
zuulToJSON Text
"status"

-- | Get the change from a pipeline
pipelineChanges ::
  -- | The pipeline name
  Text ->
  -- | An optional queue name
  Maybe Text ->
  -- | The status record
  Status ->
  -- | Returns an optional list of changes
  Maybe [Change]
pipelineChanges :: Text -> Maybe Text -> Status -> Maybe [Change]
pipelineChanges Text
name Maybe Text
queueName Status
status =
  case (Pipeline -> Bool) -> [Pipeline] -> [Pipeline]
forall a. (a -> Bool) -> [a] -> [a]
filter (\Pipeline
c -> Pipeline -> Text
pipelineName Pipeline
c Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
name) (Status -> [Pipeline]
statusPipelines Status
status) of
    [Pipeline
pipeline] -> [Change] -> Maybe [Change]
forall a. a -> Maybe a
Just ([Change] -> Maybe [Change]) -> [Change] -> Maybe [Change]
forall a b. (a -> b) -> a -> b
$ Pipeline -> [Change]
processPipeline Pipeline
pipeline
    [Pipeline]
_ -> Maybe [Change]
forall a. Maybe a
Nothing
  where
    processPipeline :: Pipeline -> [Change]
    processPipeline :: Pipeline -> [Change]
processPipeline Pipeline
pipeline = (ChangeQueue -> [Change]) -> [ChangeQueue] -> [Change]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ChangeQueue -> [Change]
processQueue (Pipeline -> [ChangeQueue]
pipelineChangeQueues Pipeline
pipeline)
    processQueue :: ChangeQueue -> [Change]
    processQueue :: ChangeQueue -> [Change]
processQueue ChangeQueue
queue = case Maybe Text
queueName of
      Just Text
queueName' ->
        if ChangeQueue -> Text
changeQueueName ChangeQueue
queue Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
queueName'
          then (Changes -> [Change]) -> [Changes] -> [Change]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Changes -> [Change]
processChanges (ChangeQueue -> [Changes]
changeQueueHeads ChangeQueue
queue)
          else []
      Maybe Text
Nothing -> (Changes -> [Change]) -> [Changes] -> [Change]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Changes -> [Change]
processChanges (ChangeQueue -> [Changes]
changeQueueHeads ChangeQueue
queue)
    processChanges :: Changes -> [Change]
    processChanges :: Changes -> [Change]
processChanges (Changes [Change]
changes) = [Change]
changes

-- | Filter the change that are live and active
liveChanges :: [Change] -> [Change]
liveChanges :: [Change] -> [Change]
liveChanges = (Change -> Bool) -> [Change] -> [Change]
forall a. (a -> Bool) -> [a] -> [a]
filter (\Change
c -> Change -> Bool
changeLive Change
c Bool -> Bool -> Bool
&& Change -> Bool
changeActive Change
c)

-- | Extract the job uuids from a list of change
changeJobUuid :: [Change] -> [Text]
changeJobUuid :: [Change] -> [Text]
changeJobUuid = (Change -> [Text]) -> [Change] -> [Text]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Change -> [Text]
go
  where
    go :: Change -> [Text]
    go :: Change -> [Text]
go Change {Bool
[JobStatus]
Maybe Text
Text
changeJobs :: [JobStatus]
changeActive :: Bool
changeLive :: Bool
changeProject :: Text
changeRef :: Text
changeId :: Maybe Text
changeJobs :: Change -> [JobStatus]
changeActive :: Change -> Bool
changeLive :: Change -> Bool
changeProject :: Change -> Text
changeRef :: Change -> Text
changeId :: Change -> Maybe Text
..} = [JobStatus] -> [Text]
getUuids [JobStatus]
changeJobs
    getUuids :: [JobStatus] -> [Text]
    getUuids :: [JobStatus] -> [Text]
getUuids [JobStatus]
jobs = do
      JobStatus
job <- [JobStatus]
jobs
      Bool -> [()]
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> [()]) -> Bool -> [()]
forall a b. (a -> b) -> a -> b
$ Maybe Text -> Bool
forall a. Maybe a -> Bool
isJust (JobStatus -> Maybe Text
jobUuid JobStatus
job)
      Text -> [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> [Text]) -> Text -> [Text]
forall a b. (a -> b) -> a -> b
$ Maybe Text -> Text
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Text -> Text) -> Maybe Text -> Text
forall a b. (a -> b) -> a -> b
$ JobStatus -> Maybe Text
jobUuid JobStatus
job