{-# 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.QuickSight.Types.FilterGroup
-- 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.QuickSight.Types.FilterGroup 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.QuickSight.Types.CrossDatasetTypes
import Amazonka.QuickSight.Types.Filter
import Amazonka.QuickSight.Types.FilterScopeConfiguration
import Amazonka.QuickSight.Types.WidgetStatus

-- | A grouping of individual filters. Filter groups are applied to the same
-- group of visuals.
--
-- For more information, see
-- <https://docs.aws.amazon.com/quicksight/latest/user/add-a-compound-filter.html Adding filter conditions (group filters) with AND and OR operators>
-- in the /Amazon QuickSight User Guide/.
--
-- /See:/ 'newFilterGroup' smart constructor.
data FilterGroup = FilterGroup'
  { -- | The status of the @FilterGroup@.
    FilterGroup -> Maybe WidgetStatus
status :: Prelude.Maybe WidgetStatus,
    -- | The value that uniquely identifies a @FilterGroup@ within a dashboard,
    -- template, or analysis.
    FilterGroup -> Text
filterGroupId :: Prelude.Text,
    -- | The list of filters that are present in a @FilterGroup@.
    FilterGroup -> [Filter]
filters :: [Filter],
    -- | The configuration that specifies what scope to apply to a @FilterGroup@.
    --
    -- This is a union type structure. For this structure to be valid, only one
    -- of the attributes can be defined.
    FilterGroup -> FilterScopeConfiguration
scopeConfiguration :: FilterScopeConfiguration,
    -- | The filter new feature which can apply filter group to all data sets.
    -- Choose one of the following options:
    --
    -- -   @ALL_DATASETS@
    --
    -- -   @SINGLE_DATASET@
    FilterGroup -> CrossDatasetTypes
crossDataset :: CrossDatasetTypes
  }
  deriving (FilterGroup -> FilterGroup -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FilterGroup -> FilterGroup -> Bool
$c/= :: FilterGroup -> FilterGroup -> Bool
== :: FilterGroup -> FilterGroup -> Bool
$c== :: FilterGroup -> FilterGroup -> Bool
Prelude.Eq, Int -> FilterGroup -> ShowS
[FilterGroup] -> ShowS
FilterGroup -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FilterGroup] -> ShowS
$cshowList :: [FilterGroup] -> ShowS
show :: FilterGroup -> String
$cshow :: FilterGroup -> String
showsPrec :: Int -> FilterGroup -> ShowS
$cshowsPrec :: Int -> FilterGroup -> ShowS
Prelude.Show, forall x. Rep FilterGroup x -> FilterGroup
forall x. FilterGroup -> Rep FilterGroup x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FilterGroup x -> FilterGroup
$cfrom :: forall x. FilterGroup -> Rep FilterGroup x
Prelude.Generic)

-- |
-- Create a value of 'FilterGroup' 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:
--
-- 'status', 'filterGroup_status' - The status of the @FilterGroup@.
--
-- 'filterGroupId', 'filterGroup_filterGroupId' - The value that uniquely identifies a @FilterGroup@ within a dashboard,
-- template, or analysis.
--
-- 'filters', 'filterGroup_filters' - The list of filters that are present in a @FilterGroup@.
--
-- 'scopeConfiguration', 'filterGroup_scopeConfiguration' - The configuration that specifies what scope to apply to a @FilterGroup@.
--
-- This is a union type structure. For this structure to be valid, only one
-- of the attributes can be defined.
--
-- 'crossDataset', 'filterGroup_crossDataset' - The filter new feature which can apply filter group to all data sets.
-- Choose one of the following options:
--
-- -   @ALL_DATASETS@
--
-- -   @SINGLE_DATASET@
newFilterGroup ::
  -- | 'filterGroupId'
  Prelude.Text ->
  -- | 'scopeConfiguration'
  FilterScopeConfiguration ->
  -- | 'crossDataset'
  CrossDatasetTypes ->
  FilterGroup
newFilterGroup :: Text
-> FilterScopeConfiguration -> CrossDatasetTypes -> FilterGroup
newFilterGroup
  Text
pFilterGroupId_
  FilterScopeConfiguration
pScopeConfiguration_
  CrossDatasetTypes
pCrossDataset_ =
    FilterGroup'
      { $sel:status:FilterGroup' :: Maybe WidgetStatus
status = forall a. Maybe a
Prelude.Nothing,
        $sel:filterGroupId:FilterGroup' :: Text
filterGroupId = Text
pFilterGroupId_,
        $sel:filters:FilterGroup' :: [Filter]
filters = forall a. Monoid a => a
Prelude.mempty,
        $sel:scopeConfiguration:FilterGroup' :: FilterScopeConfiguration
scopeConfiguration = FilterScopeConfiguration
pScopeConfiguration_,
        $sel:crossDataset:FilterGroup' :: CrossDatasetTypes
crossDataset = CrossDatasetTypes
pCrossDataset_
      }

-- | The status of the @FilterGroup@.
filterGroup_status :: Lens.Lens' FilterGroup (Prelude.Maybe WidgetStatus)
filterGroup_status :: Lens' FilterGroup (Maybe WidgetStatus)
filterGroup_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\FilterGroup' {Maybe WidgetStatus
status :: Maybe WidgetStatus
$sel:status:FilterGroup' :: FilterGroup -> Maybe WidgetStatus
status} -> Maybe WidgetStatus
status) (\s :: FilterGroup
s@FilterGroup' {} Maybe WidgetStatus
a -> FilterGroup
s {$sel:status:FilterGroup' :: Maybe WidgetStatus
status = Maybe WidgetStatus
a} :: FilterGroup)

-- | The value that uniquely identifies a @FilterGroup@ within a dashboard,
-- template, or analysis.
filterGroup_filterGroupId :: Lens.Lens' FilterGroup Prelude.Text
filterGroup_filterGroupId :: Lens' FilterGroup Text
filterGroup_filterGroupId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\FilterGroup' {Text
filterGroupId :: Text
$sel:filterGroupId:FilterGroup' :: FilterGroup -> Text
filterGroupId} -> Text
filterGroupId) (\s :: FilterGroup
s@FilterGroup' {} Text
a -> FilterGroup
s {$sel:filterGroupId:FilterGroup' :: Text
filterGroupId = Text
a} :: FilterGroup)

-- | The list of filters that are present in a @FilterGroup@.
filterGroup_filters :: Lens.Lens' FilterGroup [Filter]
filterGroup_filters :: Lens' FilterGroup [Filter]
filterGroup_filters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\FilterGroup' {[Filter]
filters :: [Filter]
$sel:filters:FilterGroup' :: FilterGroup -> [Filter]
filters} -> [Filter]
filters) (\s :: FilterGroup
s@FilterGroup' {} [Filter]
a -> FilterGroup
s {$sel:filters:FilterGroup' :: [Filter]
filters = [Filter]
a} :: FilterGroup) 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

-- | The configuration that specifies what scope to apply to a @FilterGroup@.
--
-- This is a union type structure. For this structure to be valid, only one
-- of the attributes can be defined.
filterGroup_scopeConfiguration :: Lens.Lens' FilterGroup FilterScopeConfiguration
filterGroup_scopeConfiguration :: Lens' FilterGroup FilterScopeConfiguration
filterGroup_scopeConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\FilterGroup' {FilterScopeConfiguration
scopeConfiguration :: FilterScopeConfiguration
$sel:scopeConfiguration:FilterGroup' :: FilterGroup -> FilterScopeConfiguration
scopeConfiguration} -> FilterScopeConfiguration
scopeConfiguration) (\s :: FilterGroup
s@FilterGroup' {} FilterScopeConfiguration
a -> FilterGroup
s {$sel:scopeConfiguration:FilterGroup' :: FilterScopeConfiguration
scopeConfiguration = FilterScopeConfiguration
a} :: FilterGroup)

-- | The filter new feature which can apply filter group to all data sets.
-- Choose one of the following options:
--
-- -   @ALL_DATASETS@
--
-- -   @SINGLE_DATASET@
filterGroup_crossDataset :: Lens.Lens' FilterGroup CrossDatasetTypes
filterGroup_crossDataset :: Lens' FilterGroup CrossDatasetTypes
filterGroup_crossDataset = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\FilterGroup' {CrossDatasetTypes
crossDataset :: CrossDatasetTypes
$sel:crossDataset:FilterGroup' :: FilterGroup -> CrossDatasetTypes
crossDataset} -> CrossDatasetTypes
crossDataset) (\s :: FilterGroup
s@FilterGroup' {} CrossDatasetTypes
a -> FilterGroup
s {$sel:crossDataset:FilterGroup' :: CrossDatasetTypes
crossDataset = CrossDatasetTypes
a} :: FilterGroup)

instance Data.FromJSON FilterGroup where
  parseJSON :: Value -> Parser FilterGroup
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"FilterGroup"
      ( \Object
x ->
          Maybe WidgetStatus
-> Text
-> [Filter]
-> FilterScopeConfiguration
-> CrossDatasetTypes
-> FilterGroup
FilterGroup'
            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
"Status")
            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
"FilterGroupId")
            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
"Filters" 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 a
Data..: Key
"ScopeConfiguration")
            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
"CrossDataset")
      )

instance Prelude.Hashable FilterGroup where
  hashWithSalt :: Int -> FilterGroup -> Int
hashWithSalt Int
_salt FilterGroup' {[Filter]
Maybe WidgetStatus
Text
CrossDatasetTypes
FilterScopeConfiguration
crossDataset :: CrossDatasetTypes
scopeConfiguration :: FilterScopeConfiguration
filters :: [Filter]
filterGroupId :: Text
status :: Maybe WidgetStatus
$sel:crossDataset:FilterGroup' :: FilterGroup -> CrossDatasetTypes
$sel:scopeConfiguration:FilterGroup' :: FilterGroup -> FilterScopeConfiguration
$sel:filters:FilterGroup' :: FilterGroup -> [Filter]
$sel:filterGroupId:FilterGroup' :: FilterGroup -> Text
$sel:status:FilterGroup' :: FilterGroup -> Maybe WidgetStatus
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe WidgetStatus
status
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
filterGroupId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [Filter]
filters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` FilterScopeConfiguration
scopeConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` CrossDatasetTypes
crossDataset

instance Prelude.NFData FilterGroup where
  rnf :: FilterGroup -> ()
rnf FilterGroup' {[Filter]
Maybe WidgetStatus
Text
CrossDatasetTypes
FilterScopeConfiguration
crossDataset :: CrossDatasetTypes
scopeConfiguration :: FilterScopeConfiguration
filters :: [Filter]
filterGroupId :: Text
status :: Maybe WidgetStatus
$sel:crossDataset:FilterGroup' :: FilterGroup -> CrossDatasetTypes
$sel:scopeConfiguration:FilterGroup' :: FilterGroup -> FilterScopeConfiguration
$sel:filters:FilterGroup' :: FilterGroup -> [Filter]
$sel:filterGroupId:FilterGroup' :: FilterGroup -> Text
$sel:status:FilterGroup' :: FilterGroup -> Maybe WidgetStatus
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe WidgetStatus
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
filterGroupId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Filter]
filters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf FilterScopeConfiguration
scopeConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf CrossDatasetTypes
crossDataset

instance Data.ToJSON FilterGroup where
  toJSON :: FilterGroup -> Value
toJSON FilterGroup' {[Filter]
Maybe WidgetStatus
Text
CrossDatasetTypes
FilterScopeConfiguration
crossDataset :: CrossDatasetTypes
scopeConfiguration :: FilterScopeConfiguration
filters :: [Filter]
filterGroupId :: Text
status :: Maybe WidgetStatus
$sel:crossDataset:FilterGroup' :: FilterGroup -> CrossDatasetTypes
$sel:scopeConfiguration:FilterGroup' :: FilterGroup -> FilterScopeConfiguration
$sel:filters:FilterGroup' :: FilterGroup -> [Filter]
$sel:filterGroupId:FilterGroup' :: FilterGroup -> Text
$sel:status:FilterGroup' :: FilterGroup -> Maybe WidgetStatus
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Status" 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 WidgetStatus
status,
            forall a. a -> Maybe a
Prelude.Just (Key
"FilterGroupId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
filterGroupId),
            forall a. a -> Maybe a
Prelude.Just (Key
"Filters" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= [Filter]
filters),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"ScopeConfiguration" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= FilterScopeConfiguration
scopeConfiguration),
            forall a. a -> Maybe a
Prelude.Just (Key
"CrossDataset" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= CrossDatasetTypes
crossDataset)
          ]
      )