{-# 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.TriggerUpdate
-- 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.TriggerUpdate 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 qualified Amazonka.Prelude as Prelude

-- | A structure used to provide information used to update a trigger. This
-- object updates the previous trigger definition by overwriting it
-- completely.
--
-- /See:/ 'newTriggerUpdate' smart constructor.
data TriggerUpdate = TriggerUpdate'
  { -- | The actions initiated by this trigger.
    TriggerUpdate -> Maybe [Action]
actions :: Prelude.Maybe [Action],
    -- | A description of this trigger.
    TriggerUpdate -> 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.
    TriggerUpdate -> Maybe EventBatchingCondition
eventBatchingCondition :: Prelude.Maybe EventBatchingCondition,
    -- | Reserved for future use.
    TriggerUpdate -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The predicate of this trigger, which defines when it will fire.
    TriggerUpdate -> 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 * * ? *)@.
    TriggerUpdate -> Maybe Text
schedule :: Prelude.Maybe Prelude.Text
  }
  deriving (TriggerUpdate -> TriggerUpdate -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TriggerUpdate -> TriggerUpdate -> Bool
$c/= :: TriggerUpdate -> TriggerUpdate -> Bool
== :: TriggerUpdate -> TriggerUpdate -> Bool
$c== :: TriggerUpdate -> TriggerUpdate -> Bool
Prelude.Eq, ReadPrec [TriggerUpdate]
ReadPrec TriggerUpdate
Int -> ReadS TriggerUpdate
ReadS [TriggerUpdate]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TriggerUpdate]
$creadListPrec :: ReadPrec [TriggerUpdate]
readPrec :: ReadPrec TriggerUpdate
$creadPrec :: ReadPrec TriggerUpdate
readList :: ReadS [TriggerUpdate]
$creadList :: ReadS [TriggerUpdate]
readsPrec :: Int -> ReadS TriggerUpdate
$creadsPrec :: Int -> ReadS TriggerUpdate
Prelude.Read, Int -> TriggerUpdate -> ShowS
[TriggerUpdate] -> ShowS
TriggerUpdate -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TriggerUpdate] -> ShowS
$cshowList :: [TriggerUpdate] -> ShowS
show :: TriggerUpdate -> String
$cshow :: TriggerUpdate -> String
showsPrec :: Int -> TriggerUpdate -> ShowS
$cshowsPrec :: Int -> TriggerUpdate -> ShowS
Prelude.Show, forall x. Rep TriggerUpdate x -> TriggerUpdate
forall x. TriggerUpdate -> Rep TriggerUpdate x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TriggerUpdate x -> TriggerUpdate
$cfrom :: forall x. TriggerUpdate -> Rep TriggerUpdate x
Prelude.Generic)

-- |
-- Create a value of 'TriggerUpdate' 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', 'triggerUpdate_actions' - The actions initiated by this trigger.
--
-- 'description', 'triggerUpdate_description' - A description of this trigger.
--
-- 'eventBatchingCondition', 'triggerUpdate_eventBatchingCondition' - Batch condition that must be met (specified number of events received or
-- batch time window expired) before EventBridge event trigger fires.
--
-- 'name', 'triggerUpdate_name' - Reserved for future use.
--
-- 'predicate', 'triggerUpdate_predicate' - The predicate of this trigger, which defines when it will fire.
--
-- 'schedule', 'triggerUpdate_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 * * ? *)@.
newTriggerUpdate ::
  TriggerUpdate
newTriggerUpdate :: TriggerUpdate
newTriggerUpdate =
  TriggerUpdate'
    { $sel:actions:TriggerUpdate' :: Maybe [Action]
actions = forall a. Maybe a
Prelude.Nothing,
      $sel:description:TriggerUpdate' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:eventBatchingCondition:TriggerUpdate' :: Maybe EventBatchingCondition
eventBatchingCondition = forall a. Maybe a
Prelude.Nothing,
      $sel:name:TriggerUpdate' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:predicate:TriggerUpdate' :: Maybe Predicate
predicate = forall a. Maybe a
Prelude.Nothing,
      $sel:schedule:TriggerUpdate' :: Maybe Text
schedule = forall a. Maybe a
Prelude.Nothing
    }

-- | The actions initiated by this trigger.
triggerUpdate_actions :: Lens.Lens' TriggerUpdate (Prelude.Maybe [Action])
triggerUpdate_actions :: Lens' TriggerUpdate (Maybe [Action])
triggerUpdate_actions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TriggerUpdate' {Maybe [Action]
actions :: Maybe [Action]
$sel:actions:TriggerUpdate' :: TriggerUpdate -> Maybe [Action]
actions} -> Maybe [Action]
actions) (\s :: TriggerUpdate
s@TriggerUpdate' {} Maybe [Action]
a -> TriggerUpdate
s {$sel:actions:TriggerUpdate' :: Maybe [Action]
actions = Maybe [Action]
a} :: TriggerUpdate) 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.
triggerUpdate_description :: Lens.Lens' TriggerUpdate (Prelude.Maybe Prelude.Text)
triggerUpdate_description :: Lens' TriggerUpdate (Maybe Text)
triggerUpdate_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TriggerUpdate' {Maybe Text
description :: Maybe Text
$sel:description:TriggerUpdate' :: TriggerUpdate -> Maybe Text
description} -> Maybe Text
description) (\s :: TriggerUpdate
s@TriggerUpdate' {} Maybe Text
a -> TriggerUpdate
s {$sel:description:TriggerUpdate' :: Maybe Text
description = Maybe Text
a} :: TriggerUpdate)

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

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

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

-- | 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 * * ? *)@.
triggerUpdate_schedule :: Lens.Lens' TriggerUpdate (Prelude.Maybe Prelude.Text)
triggerUpdate_schedule :: Lens' TriggerUpdate (Maybe Text)
triggerUpdate_schedule = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TriggerUpdate' {Maybe Text
schedule :: Maybe Text
$sel:schedule:TriggerUpdate' :: TriggerUpdate -> Maybe Text
schedule} -> Maybe Text
schedule) (\s :: TriggerUpdate
s@TriggerUpdate' {} Maybe Text
a -> TriggerUpdate
s {$sel:schedule:TriggerUpdate' :: Maybe Text
schedule = Maybe Text
a} :: TriggerUpdate)

instance Prelude.Hashable TriggerUpdate where
  hashWithSalt :: Int -> TriggerUpdate -> Int
hashWithSalt Int
_salt TriggerUpdate' {Maybe [Action]
Maybe Text
Maybe EventBatchingCondition
Maybe Predicate
schedule :: Maybe Text
predicate :: Maybe Predicate
name :: Maybe Text
eventBatchingCondition :: Maybe EventBatchingCondition
description :: Maybe Text
actions :: Maybe [Action]
$sel:schedule:TriggerUpdate' :: TriggerUpdate -> Maybe Text
$sel:predicate:TriggerUpdate' :: TriggerUpdate -> Maybe Predicate
$sel:name:TriggerUpdate' :: TriggerUpdate -> Maybe Text
$sel:eventBatchingCondition:TriggerUpdate' :: TriggerUpdate -> Maybe EventBatchingCondition
$sel:description:TriggerUpdate' :: TriggerUpdate -> Maybe Text
$sel:actions:TriggerUpdate' :: TriggerUpdate -> 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
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

instance Prelude.NFData TriggerUpdate where
  rnf :: TriggerUpdate -> ()
rnf TriggerUpdate' {Maybe [Action]
Maybe Text
Maybe EventBatchingCondition
Maybe Predicate
schedule :: Maybe Text
predicate :: Maybe Predicate
name :: Maybe Text
eventBatchingCondition :: Maybe EventBatchingCondition
description :: Maybe Text
actions :: Maybe [Action]
$sel:schedule:TriggerUpdate' :: TriggerUpdate -> Maybe Text
$sel:predicate:TriggerUpdate' :: TriggerUpdate -> Maybe Predicate
$sel:name:TriggerUpdate' :: TriggerUpdate -> Maybe Text
$sel:eventBatchingCondition:TriggerUpdate' :: TriggerUpdate -> Maybe EventBatchingCondition
$sel:description:TriggerUpdate' :: TriggerUpdate -> Maybe Text
$sel:actions:TriggerUpdate' :: TriggerUpdate -> 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
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

instance Data.ToJSON TriggerUpdate where
  toJSON :: TriggerUpdate -> Value
toJSON TriggerUpdate' {Maybe [Action]
Maybe Text
Maybe EventBatchingCondition
Maybe Predicate
schedule :: Maybe Text
predicate :: Maybe Predicate
name :: Maybe Text
eventBatchingCondition :: Maybe EventBatchingCondition
description :: Maybe Text
actions :: Maybe [Action]
$sel:schedule:TriggerUpdate' :: TriggerUpdate -> Maybe Text
$sel:predicate:TriggerUpdate' :: TriggerUpdate -> Maybe Predicate
$sel:name:TriggerUpdate' :: TriggerUpdate -> Maybe Text
$sel:eventBatchingCondition:TriggerUpdate' :: TriggerUpdate -> Maybe EventBatchingCondition
$sel:description:TriggerUpdate' :: TriggerUpdate -> Maybe Text
$sel:actions:TriggerUpdate' :: TriggerUpdate -> Maybe [Action]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Actions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Action]
actions,
            (Key
"Description" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
description,
            (Key
"EventBatchingCondition" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe EventBatchingCondition
eventBatchingCondition,
            (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
name,
            (Key
"Predicate" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Predicate
predicate,
            (Key
"Schedule" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
schedule
          ]
      )