{-# 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.WAFV2.Types.Filter
-- 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.WAFV2.Types.Filter where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import Amazonka.WAFV2.Types.Condition
import Amazonka.WAFV2.Types.FilterBehavior
import Amazonka.WAFV2.Types.FilterRequirement

-- | A single logging filter, used in LoggingFilter.
--
-- /See:/ 'newFilter' smart constructor.
data Filter = Filter'
  { -- | How to handle logs that satisfy the filter\'s conditions and
    -- requirement.
    Filter -> FilterBehavior
behavior :: FilterBehavior,
    -- | Logic to apply to the filtering conditions. You can specify that, in
    -- order to satisfy the filter, a log must match all conditions or must
    -- match at least one condition.
    Filter -> FilterRequirement
requirement :: FilterRequirement,
    -- | Match conditions for the filter.
    Filter -> NonEmpty Condition
conditions :: Prelude.NonEmpty Condition
  }
  deriving (Filter -> Filter -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Filter -> Filter -> Bool
$c/= :: Filter -> Filter -> Bool
== :: Filter -> Filter -> Bool
$c== :: Filter -> Filter -> Bool
Prelude.Eq, ReadPrec [Filter]
ReadPrec Filter
Int -> ReadS Filter
ReadS [Filter]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Filter]
$creadListPrec :: ReadPrec [Filter]
readPrec :: ReadPrec Filter
$creadPrec :: ReadPrec Filter
readList :: ReadS [Filter]
$creadList :: ReadS [Filter]
readsPrec :: Int -> ReadS Filter
$creadsPrec :: Int -> ReadS Filter
Prelude.Read, Int -> Filter -> ShowS
[Filter] -> ShowS
Filter -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Filter] -> ShowS
$cshowList :: [Filter] -> ShowS
show :: Filter -> String
$cshow :: Filter -> String
showsPrec :: Int -> Filter -> ShowS
$cshowsPrec :: Int -> Filter -> ShowS
Prelude.Show, forall x. Rep Filter x -> Filter
forall x. Filter -> Rep Filter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Filter x -> Filter
$cfrom :: forall x. Filter -> Rep Filter x
Prelude.Generic)

-- |
-- Create a value of 'Filter' 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:
--
-- 'behavior', 'filter_behavior' - How to handle logs that satisfy the filter\'s conditions and
-- requirement.
--
-- 'requirement', 'filter_requirement' - Logic to apply to the filtering conditions. You can specify that, in
-- order to satisfy the filter, a log must match all conditions or must
-- match at least one condition.
--
-- 'conditions', 'filter_conditions' - Match conditions for the filter.
newFilter ::
  -- | 'behavior'
  FilterBehavior ->
  -- | 'requirement'
  FilterRequirement ->
  -- | 'conditions'
  Prelude.NonEmpty Condition ->
  Filter
newFilter :: FilterBehavior -> FilterRequirement -> NonEmpty Condition -> Filter
newFilter FilterBehavior
pBehavior_ FilterRequirement
pRequirement_ NonEmpty Condition
pConditions_ =
  Filter'
    { $sel:behavior:Filter' :: FilterBehavior
behavior = FilterBehavior
pBehavior_,
      $sel:requirement:Filter' :: FilterRequirement
requirement = FilterRequirement
pRequirement_,
      $sel:conditions:Filter' :: NonEmpty Condition
conditions = forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced forall t b. AReview t b -> b -> t
Lens.# NonEmpty Condition
pConditions_
    }

-- | How to handle logs that satisfy the filter\'s conditions and
-- requirement.
filter_behavior :: Lens.Lens' Filter FilterBehavior
filter_behavior :: Lens' Filter FilterBehavior
filter_behavior = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Filter' {FilterBehavior
behavior :: FilterBehavior
$sel:behavior:Filter' :: Filter -> FilterBehavior
behavior} -> FilterBehavior
behavior) (\s :: Filter
s@Filter' {} FilterBehavior
a -> Filter
s {$sel:behavior:Filter' :: FilterBehavior
behavior = FilterBehavior
a} :: Filter)

-- | Logic to apply to the filtering conditions. You can specify that, in
-- order to satisfy the filter, a log must match all conditions or must
-- match at least one condition.
filter_requirement :: Lens.Lens' Filter FilterRequirement
filter_requirement :: Lens' Filter FilterRequirement
filter_requirement = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Filter' {FilterRequirement
requirement :: FilterRequirement
$sel:requirement:Filter' :: Filter -> FilterRequirement
requirement} -> FilterRequirement
requirement) (\s :: Filter
s@Filter' {} FilterRequirement
a -> Filter
s {$sel:requirement:Filter' :: FilterRequirement
requirement = FilterRequirement
a} :: Filter)

-- | Match conditions for the filter.
filter_conditions :: Lens.Lens' Filter (Prelude.NonEmpty Condition)
filter_conditions :: Lens' Filter (NonEmpty Condition)
filter_conditions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Filter' {NonEmpty Condition
conditions :: NonEmpty Condition
$sel:conditions:Filter' :: Filter -> NonEmpty Condition
conditions} -> NonEmpty Condition
conditions) (\s :: Filter
s@Filter' {} NonEmpty Condition
a -> Filter
s {$sel:conditions:Filter' :: NonEmpty Condition
conditions = NonEmpty Condition
a} :: Filter) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Data.FromJSON Filter where
  parseJSON :: Value -> Parser Filter
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Filter"
      ( \Object
x ->
          FilterBehavior -> FilterRequirement -> NonEmpty Condition -> Filter
Filter'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Behavior")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Requirement")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Conditions")
      )

instance Prelude.Hashable Filter where
  hashWithSalt :: Int -> Filter -> Int
hashWithSalt Int
_salt Filter' {NonEmpty Condition
FilterBehavior
FilterRequirement
conditions :: NonEmpty Condition
requirement :: FilterRequirement
behavior :: FilterBehavior
$sel:conditions:Filter' :: Filter -> NonEmpty Condition
$sel:requirement:Filter' :: Filter -> FilterRequirement
$sel:behavior:Filter' :: Filter -> FilterBehavior
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` FilterBehavior
behavior
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` FilterRequirement
requirement
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty Condition
conditions

instance Prelude.NFData Filter where
  rnf :: Filter -> ()
rnf Filter' {NonEmpty Condition
FilterBehavior
FilterRequirement
conditions :: NonEmpty Condition
requirement :: FilterRequirement
behavior :: FilterBehavior
$sel:conditions:Filter' :: Filter -> NonEmpty Condition
$sel:requirement:Filter' :: Filter -> FilterRequirement
$sel:behavior:Filter' :: Filter -> FilterBehavior
..} =
    forall a. NFData a => a -> ()
Prelude.rnf FilterBehavior
behavior
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf FilterRequirement
requirement
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty Condition
conditions

instance Data.ToJSON Filter where
  toJSON :: Filter -> Value
toJSON Filter' {NonEmpty Condition
FilterBehavior
FilterRequirement
conditions :: NonEmpty Condition
requirement :: FilterRequirement
behavior :: FilterBehavior
$sel:conditions:Filter' :: Filter -> NonEmpty Condition
$sel:requirement:Filter' :: Filter -> FilterRequirement
$sel:behavior:Filter' :: Filter -> FilterBehavior
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just (Key
"Behavior" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= FilterBehavior
behavior),
            forall a. a -> Maybe a
Prelude.Just (Key
"Requirement" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= FilterRequirement
requirement),
            forall a. a -> Maybe a
Prelude.Just (Key
"Conditions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty Condition
conditions)
          ]
      )