{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.Glue.Types.Trigger
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.Glue.Types.Trigger where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Glue.Types.Action
import Amazonka.Glue.Types.EventBatchingCondition
import Amazonka.Glue.Types.Predicate
import Amazonka.Glue.Types.TriggerState
import Amazonka.Glue.Types.TriggerType
import qualified Amazonka.Prelude as Prelude

-- | Information about a specific trigger.
--
-- /See:/ 'newTrigger' smart constructor.
data Trigger = Trigger'
  { -- | The actions initiated by this trigger.
    Trigger -> Maybe [Action]
actions :: Prelude.Maybe [Action],
    -- | A description of this trigger.
    Trigger -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | Batch condition that must be met (specified number of events received or
    -- batch time window expired) before EventBridge event trigger fires.
    Trigger -> Maybe EventBatchingCondition
eventBatchingCondition :: Prelude.Maybe EventBatchingCondition,
    -- | Reserved for future use.
    Trigger -> Maybe Text
id :: Prelude.Maybe Prelude.Text,
    -- | The name of the trigger.
    Trigger -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The predicate of this trigger, which defines when it will fire.
    Trigger -> Maybe Predicate
predicate :: Prelude.Maybe Predicate,
    -- | A @cron@ expression used to specify the schedule (see
    -- <https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html Time-Based Schedules for Jobs and Crawlers>.
    -- For example, to run something every day at 12:15 UTC, you would specify:
    -- @cron(15 12 * * ? *)@.
    Trigger -> Maybe Text
schedule :: Prelude.Maybe Prelude.Text,
    -- | The current state of the trigger.
    Trigger -> Maybe TriggerState
state :: Prelude.Maybe TriggerState,
    -- | The type of trigger that this is.
    Trigger -> Maybe TriggerType
type' :: Prelude.Maybe TriggerType,
    -- | The name of the workflow associated with the trigger.
    Trigger -> Maybe Text
workflowName :: Prelude.Maybe Prelude.Text
  }
  deriving (Trigger -> Trigger -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Trigger -> Trigger -> Bool
$c/= :: Trigger -> Trigger -> Bool
== :: Trigger -> Trigger -> Bool
$c== :: Trigger -> Trigger -> Bool
Prelude.Eq, ReadPrec [Trigger]
ReadPrec Trigger
Int -> ReadS Trigger
ReadS [Trigger]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Trigger]
$creadListPrec :: ReadPrec [Trigger]
readPrec :: ReadPrec Trigger
$creadPrec :: ReadPrec Trigger
readList :: ReadS [Trigger]
$creadList :: ReadS [Trigger]
readsPrec :: Int -> ReadS Trigger
$creadsPrec :: Int -> ReadS Trigger
Prelude.Read, Int -> Trigger -> ShowS
[Trigger] -> ShowS
Trigger -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Trigger] -> ShowS
$cshowList :: [Trigger] -> ShowS
show :: Trigger -> String
$cshow :: Trigger -> String
showsPrec :: Int -> Trigger -> ShowS
$cshowsPrec :: Int -> Trigger -> ShowS
Prelude.Show, forall x. Rep Trigger x -> Trigger
forall x. Trigger -> Rep Trigger x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Trigger x -> Trigger
$cfrom :: forall x. Trigger -> Rep Trigger x
Prelude.Generic)

-- |
-- Create a value of 'Trigger' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'actions', 'trigger_actions' - The actions initiated by this trigger.
--
-- 'description', 'trigger_description' - A description of this trigger.
--
-- 'eventBatchingCondition', 'trigger_eventBatchingCondition' - Batch condition that must be met (specified number of events received or
-- batch time window expired) before EventBridge event trigger fires.
--
-- 'id', 'trigger_id' - Reserved for future use.
--
-- 'name', 'trigger_name' - The name of the trigger.
--
-- 'predicate', 'trigger_predicate' - The predicate of this trigger, which defines when it will fire.
--
-- 'schedule', 'trigger_schedule' - A @cron@ expression used to specify the schedule (see
-- <https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html Time-Based Schedules for Jobs and Crawlers>.
-- For example, to run something every day at 12:15 UTC, you would specify:
-- @cron(15 12 * * ? *)@.
--
-- 'state', 'trigger_state' - The current state of the trigger.
--
-- 'type'', 'trigger_type' - The type of trigger that this is.
--
-- 'workflowName', 'trigger_workflowName' - The name of the workflow associated with the trigger.
newTrigger ::
  Trigger
newTrigger :: Trigger
newTrigger =
  Trigger'
    { $sel:actions:Trigger' :: Maybe [Action]
actions = forall a. Maybe a
Prelude.Nothing,
      $sel:description:Trigger' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:eventBatchingCondition:Trigger' :: Maybe EventBatchingCondition
eventBatchingCondition = forall a. Maybe a
Prelude.Nothing,
      $sel:id:Trigger' :: Maybe Text
id = forall a. Maybe a
Prelude.Nothing,
      $sel:name:Trigger' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:predicate:Trigger' :: Maybe Predicate
predicate = forall a. Maybe a
Prelude.Nothing,
      $sel:schedule:Trigger' :: Maybe Text
schedule = forall a. Maybe a
Prelude.Nothing,
      $sel:state:Trigger' :: Maybe TriggerState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:type':Trigger' :: Maybe TriggerType
type' = forall a. Maybe a
Prelude.Nothing,
      $sel:workflowName:Trigger' :: Maybe Text
workflowName = forall a. Maybe a
Prelude.Nothing
    }

-- | The actions initiated by this trigger.
trigger_actions :: Lens.Lens' Trigger (Prelude.Maybe [Action])
trigger_actions :: Lens' Trigger (Maybe [Action])
trigger_actions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Trigger' {Maybe [Action]
actions :: Maybe [Action]
$sel:actions:Trigger' :: Trigger -> Maybe [Action]
actions} -> Maybe [Action]
actions) (\s :: Trigger
s@Trigger' {} Maybe [Action]
a -> Trigger
s {$sel:actions:Trigger' :: Maybe [Action]
actions = Maybe [Action]
a} :: Trigger) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A description of this trigger.
trigger_description :: Lens.Lens' Trigger (Prelude.Maybe Prelude.Text)
trigger_description :: Lens' Trigger (Maybe Text)
trigger_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Trigger' {Maybe Text
description :: Maybe Text
$sel:description:Trigger' :: Trigger -> Maybe Text
description} -> Maybe Text
description) (\s :: Trigger
s@Trigger' {} Maybe Text
a -> Trigger
s {$sel:description:Trigger' :: Maybe Text
description = Maybe Text
a} :: Trigger)

-- | Batch condition that must be met (specified number of events received or
-- batch time window expired) before EventBridge event trigger fires.
trigger_eventBatchingCondition :: Lens.Lens' Trigger (Prelude.Maybe EventBatchingCondition)
trigger_eventBatchingCondition :: Lens' Trigger (Maybe EventBatchingCondition)
trigger_eventBatchingCondition = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Trigger' {Maybe EventBatchingCondition
eventBatchingCondition :: Maybe EventBatchingCondition
$sel:eventBatchingCondition:Trigger' :: Trigger -> Maybe EventBatchingCondition
eventBatchingCondition} -> Maybe EventBatchingCondition
eventBatchingCondition) (\s :: Trigger
s@Trigger' {} Maybe EventBatchingCondition
a -> Trigger
s {$sel:eventBatchingCondition:Trigger' :: Maybe EventBatchingCondition
eventBatchingCondition = Maybe EventBatchingCondition
a} :: Trigger)

-- | Reserved for future use.
trigger_id :: Lens.Lens' Trigger (Prelude.Maybe Prelude.Text)
trigger_id :: Lens' Trigger (Maybe Text)
trigger_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Trigger' {Maybe Text
id :: Maybe Text
$sel:id:Trigger' :: Trigger -> Maybe Text
id} -> Maybe Text
id) (\s :: Trigger
s@Trigger' {} Maybe Text
a -> Trigger
s {$sel:id:Trigger' :: Maybe Text
id = Maybe Text
a} :: Trigger)

-- | The name of the trigger.
trigger_name :: Lens.Lens' Trigger (Prelude.Maybe Prelude.Text)
trigger_name :: Lens' Trigger (Maybe Text)
trigger_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Trigger' {Maybe Text
name :: Maybe Text
$sel:name:Trigger' :: Trigger -> Maybe Text
name} -> Maybe Text
name) (\s :: Trigger
s@Trigger' {} Maybe Text
a -> Trigger
s {$sel:name:Trigger' :: Maybe Text
name = Maybe Text
a} :: Trigger)

-- | The predicate of this trigger, which defines when it will fire.
trigger_predicate :: Lens.Lens' Trigger (Prelude.Maybe Predicate)
trigger_predicate :: Lens' Trigger (Maybe Predicate)
trigger_predicate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Trigger' {Maybe Predicate
predicate :: Maybe Predicate
$sel:predicate:Trigger' :: Trigger -> Maybe Predicate
predicate} -> Maybe Predicate
predicate) (\s :: Trigger
s@Trigger' {} Maybe Predicate
a -> Trigger
s {$sel:predicate:Trigger' :: Maybe Predicate
predicate = Maybe Predicate
a} :: Trigger)

-- | A @cron@ expression used to specify the schedule (see
-- <https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html Time-Based Schedules for Jobs and Crawlers>.
-- For example, to run something every day at 12:15 UTC, you would specify:
-- @cron(15 12 * * ? *)@.
trigger_schedule :: Lens.Lens' Trigger (Prelude.Maybe Prelude.Text)
trigger_schedule :: Lens' Trigger (Maybe Text)
trigger_schedule = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Trigger' {Maybe Text
schedule :: Maybe Text
$sel:schedule:Trigger' :: Trigger -> Maybe Text
schedule} -> Maybe Text
schedule) (\s :: Trigger
s@Trigger' {} Maybe Text
a -> Trigger
s {$sel:schedule:Trigger' :: Maybe Text
schedule = Maybe Text
a} :: Trigger)

-- | The current state of the trigger.
trigger_state :: Lens.Lens' Trigger (Prelude.Maybe TriggerState)
trigger_state :: Lens' Trigger (Maybe TriggerState)
trigger_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Trigger' {Maybe TriggerState
state :: Maybe TriggerState
$sel:state:Trigger' :: Trigger -> Maybe TriggerState
state} -> Maybe TriggerState
state) (\s :: Trigger
s@Trigger' {} Maybe TriggerState
a -> Trigger
s {$sel:state:Trigger' :: Maybe TriggerState
state = Maybe TriggerState
a} :: Trigger)

-- | The type of trigger that this is.
trigger_type :: Lens.Lens' Trigger (Prelude.Maybe TriggerType)
trigger_type :: Lens' Trigger (Maybe TriggerType)
trigger_type = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Trigger' {Maybe TriggerType
type' :: Maybe TriggerType
$sel:type':Trigger' :: Trigger -> Maybe TriggerType
type'} -> Maybe TriggerType
type') (\s :: Trigger
s@Trigger' {} Maybe TriggerType
a -> Trigger
s {$sel:type':Trigger' :: Maybe TriggerType
type' = Maybe TriggerType
a} :: Trigger)

-- | The name of the workflow associated with the trigger.
trigger_workflowName :: Lens.Lens' Trigger (Prelude.Maybe Prelude.Text)
trigger_workflowName :: Lens' Trigger (Maybe Text)
trigger_workflowName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Trigger' {Maybe Text
workflowName :: Maybe Text
$sel:workflowName:Trigger' :: Trigger -> Maybe Text
workflowName} -> Maybe Text
workflowName) (\s :: Trigger
s@Trigger' {} Maybe Text
a -> Trigger
s {$sel:workflowName:Trigger' :: Maybe Text
workflowName = Maybe Text
a} :: Trigger)

instance Data.FromJSON Trigger where
  parseJSON :: Value -> Parser Trigger
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Trigger"
      ( \Object
x ->
          Maybe [Action]
-> Maybe Text
-> Maybe EventBatchingCondition
-> Maybe Text
-> Maybe Text
-> Maybe Predicate
-> Maybe Text
-> Maybe TriggerState
-> Maybe TriggerType
-> Maybe Text
-> Trigger
Trigger'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Actions" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Description")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"EventBatchingCondition")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Id")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Name")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Predicate")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Schedule")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"State")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Type")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"WorkflowName")
      )

instance Prelude.Hashable Trigger where
  hashWithSalt :: Int -> Trigger -> Int
hashWithSalt Int
_salt Trigger' {Maybe [Action]
Maybe Text
Maybe EventBatchingCondition
Maybe Predicate
Maybe TriggerState
Maybe TriggerType
workflowName :: Maybe Text
type' :: Maybe TriggerType
state :: Maybe TriggerState
schedule :: Maybe Text
predicate :: Maybe Predicate
name :: Maybe Text
id :: Maybe Text
eventBatchingCondition :: Maybe EventBatchingCondition
description :: Maybe Text
actions :: Maybe [Action]
$sel:workflowName:Trigger' :: Trigger -> Maybe Text
$sel:type':Trigger' :: Trigger -> Maybe TriggerType
$sel:state:Trigger' :: Trigger -> Maybe TriggerState
$sel:schedule:Trigger' :: Trigger -> Maybe Text
$sel:predicate:Trigger' :: Trigger -> Maybe Predicate
$sel:name:Trigger' :: Trigger -> Maybe Text
$sel:id:Trigger' :: Trigger -> Maybe Text
$sel:eventBatchingCondition:Trigger' :: Trigger -> Maybe EventBatchingCondition
$sel:description:Trigger' :: Trigger -> Maybe Text
$sel:actions:Trigger' :: Trigger -> Maybe [Action]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Action]
actions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EventBatchingCondition
eventBatchingCondition
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
id
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Predicate
predicate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
schedule
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TriggerState
state
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TriggerType
type'
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
workflowName

instance Prelude.NFData Trigger where
  rnf :: Trigger -> ()
rnf Trigger' {Maybe [Action]
Maybe Text
Maybe EventBatchingCondition
Maybe Predicate
Maybe TriggerState
Maybe TriggerType
workflowName :: Maybe Text
type' :: Maybe TriggerType
state :: Maybe TriggerState
schedule :: Maybe Text
predicate :: Maybe Predicate
name :: Maybe Text
id :: Maybe Text
eventBatchingCondition :: Maybe EventBatchingCondition
description :: Maybe Text
actions :: Maybe [Action]
$sel:workflowName:Trigger' :: Trigger -> Maybe Text
$sel:type':Trigger' :: Trigger -> Maybe TriggerType
$sel:state:Trigger' :: Trigger -> Maybe TriggerState
$sel:schedule:Trigger' :: Trigger -> Maybe Text
$sel:predicate:Trigger' :: Trigger -> Maybe Predicate
$sel:name:Trigger' :: Trigger -> Maybe Text
$sel:id:Trigger' :: Trigger -> Maybe Text
$sel:eventBatchingCondition:Trigger' :: Trigger -> Maybe EventBatchingCondition
$sel:description:Trigger' :: Trigger -> Maybe Text
$sel:actions:Trigger' :: Trigger -> Maybe [Action]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Action]
actions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EventBatchingCondition
eventBatchingCondition
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
id
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Predicate
predicate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
schedule
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe TriggerState
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe TriggerType
type'
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
workflowName