{-# 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.HealthLake.Types.DatastoreFilter
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.HealthLake.Types.DatastoreFilter where

import qualified Amazonka.Core as Core
import Amazonka.HealthLake.Types.DatastoreStatus
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude

-- | The filters applied to Data Store query.
--
-- /See:/ 'newDatastoreFilter' smart constructor.
data DatastoreFilter = DatastoreFilter'
  { -- | A filter that allows the user to set cutoff dates for records. All Data
    -- Stores created after the specified date will be included in the results.
    DatastoreFilter -> Maybe POSIX
createdAfter :: Prelude.Maybe Core.POSIX,
    -- | Allows the user to filter Data Store results by name.
    DatastoreFilter -> Maybe Text
datastoreName :: Prelude.Maybe Prelude.Text,
    -- | Allows the user to filter Data Store results by status.
    DatastoreFilter -> Maybe DatastoreStatus
datastoreStatus :: Prelude.Maybe DatastoreStatus,
    -- | A filter that allows the user to set cutoff dates for records. All Data
    -- Stores created before the specified date will be included in the
    -- results.
    DatastoreFilter -> Maybe POSIX
createdBefore :: Prelude.Maybe Core.POSIX
  }
  deriving (DatastoreFilter -> DatastoreFilter -> Bool
(DatastoreFilter -> DatastoreFilter -> Bool)
-> (DatastoreFilter -> DatastoreFilter -> Bool)
-> Eq DatastoreFilter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DatastoreFilter -> DatastoreFilter -> Bool
$c/= :: DatastoreFilter -> DatastoreFilter -> Bool
== :: DatastoreFilter -> DatastoreFilter -> Bool
$c== :: DatastoreFilter -> DatastoreFilter -> Bool
Prelude.Eq, ReadPrec [DatastoreFilter]
ReadPrec DatastoreFilter
Int -> ReadS DatastoreFilter
ReadS [DatastoreFilter]
(Int -> ReadS DatastoreFilter)
-> ReadS [DatastoreFilter]
-> ReadPrec DatastoreFilter
-> ReadPrec [DatastoreFilter]
-> Read DatastoreFilter
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DatastoreFilter]
$creadListPrec :: ReadPrec [DatastoreFilter]
readPrec :: ReadPrec DatastoreFilter
$creadPrec :: ReadPrec DatastoreFilter
readList :: ReadS [DatastoreFilter]
$creadList :: ReadS [DatastoreFilter]
readsPrec :: Int -> ReadS DatastoreFilter
$creadsPrec :: Int -> ReadS DatastoreFilter
Prelude.Read, Int -> DatastoreFilter -> ShowS
[DatastoreFilter] -> ShowS
DatastoreFilter -> String
(Int -> DatastoreFilter -> ShowS)
-> (DatastoreFilter -> String)
-> ([DatastoreFilter] -> ShowS)
-> Show DatastoreFilter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DatastoreFilter] -> ShowS
$cshowList :: [DatastoreFilter] -> ShowS
show :: DatastoreFilter -> String
$cshow :: DatastoreFilter -> String
showsPrec :: Int -> DatastoreFilter -> ShowS
$cshowsPrec :: Int -> DatastoreFilter -> ShowS
Prelude.Show, (forall x. DatastoreFilter -> Rep DatastoreFilter x)
-> (forall x. Rep DatastoreFilter x -> DatastoreFilter)
-> Generic DatastoreFilter
forall x. Rep DatastoreFilter x -> DatastoreFilter
forall x. DatastoreFilter -> Rep DatastoreFilter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DatastoreFilter x -> DatastoreFilter
$cfrom :: forall x. DatastoreFilter -> Rep DatastoreFilter x
Prelude.Generic)

-- |
-- Create a value of 'DatastoreFilter' 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:
--
-- 'createdAfter', 'datastoreFilter_createdAfter' - A filter that allows the user to set cutoff dates for records. All Data
-- Stores created after the specified date will be included in the results.
--
-- 'datastoreName', 'datastoreFilter_datastoreName' - Allows the user to filter Data Store results by name.
--
-- 'datastoreStatus', 'datastoreFilter_datastoreStatus' - Allows the user to filter Data Store results by status.
--
-- 'createdBefore', 'datastoreFilter_createdBefore' - A filter that allows the user to set cutoff dates for records. All Data
-- Stores created before the specified date will be included in the
-- results.
newDatastoreFilter ::
  DatastoreFilter
newDatastoreFilter :: DatastoreFilter
newDatastoreFilter =
  DatastoreFilter' :: Maybe POSIX
-> Maybe Text
-> Maybe DatastoreStatus
-> Maybe POSIX
-> DatastoreFilter
DatastoreFilter'
    { $sel:createdAfter:DatastoreFilter' :: Maybe POSIX
createdAfter = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:datastoreName:DatastoreFilter' :: Maybe Text
datastoreName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:datastoreStatus:DatastoreFilter' :: Maybe DatastoreStatus
datastoreStatus = Maybe DatastoreStatus
forall a. Maybe a
Prelude.Nothing,
      $sel:createdBefore:DatastoreFilter' :: Maybe POSIX
createdBefore = Maybe POSIX
forall a. Maybe a
Prelude.Nothing
    }

-- | A filter that allows the user to set cutoff dates for records. All Data
-- Stores created after the specified date will be included in the results.
datastoreFilter_createdAfter :: Lens.Lens' DatastoreFilter (Prelude.Maybe Prelude.UTCTime)
datastoreFilter_createdAfter :: (Maybe UTCTime -> f (Maybe UTCTime))
-> DatastoreFilter -> f DatastoreFilter
datastoreFilter_createdAfter = (DatastoreFilter -> Maybe POSIX)
-> (DatastoreFilter -> Maybe POSIX -> DatastoreFilter)
-> Lens DatastoreFilter DatastoreFilter (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DatastoreFilter' {Maybe POSIX
createdAfter :: Maybe POSIX
$sel:createdAfter:DatastoreFilter' :: DatastoreFilter -> Maybe POSIX
createdAfter} -> Maybe POSIX
createdAfter) (\s :: DatastoreFilter
s@DatastoreFilter' {} Maybe POSIX
a -> DatastoreFilter
s {$sel:createdAfter:DatastoreFilter' :: Maybe POSIX
createdAfter = Maybe POSIX
a} :: DatastoreFilter) ((Maybe POSIX -> f (Maybe POSIX))
 -> DatastoreFilter -> f DatastoreFilter)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> DatastoreFilter
-> f DatastoreFilter
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
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 AnIso POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | Allows the user to filter Data Store results by name.
datastoreFilter_datastoreName :: Lens.Lens' DatastoreFilter (Prelude.Maybe Prelude.Text)
datastoreFilter_datastoreName :: (Maybe Text -> f (Maybe Text))
-> DatastoreFilter -> f DatastoreFilter
datastoreFilter_datastoreName = (DatastoreFilter -> Maybe Text)
-> (DatastoreFilter -> Maybe Text -> DatastoreFilter)
-> Lens DatastoreFilter DatastoreFilter (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DatastoreFilter' {Maybe Text
datastoreName :: Maybe Text
$sel:datastoreName:DatastoreFilter' :: DatastoreFilter -> Maybe Text
datastoreName} -> Maybe Text
datastoreName) (\s :: DatastoreFilter
s@DatastoreFilter' {} Maybe Text
a -> DatastoreFilter
s {$sel:datastoreName:DatastoreFilter' :: Maybe Text
datastoreName = Maybe Text
a} :: DatastoreFilter)

-- | Allows the user to filter Data Store results by status.
datastoreFilter_datastoreStatus :: Lens.Lens' DatastoreFilter (Prelude.Maybe DatastoreStatus)
datastoreFilter_datastoreStatus :: (Maybe DatastoreStatus -> f (Maybe DatastoreStatus))
-> DatastoreFilter -> f DatastoreFilter
datastoreFilter_datastoreStatus = (DatastoreFilter -> Maybe DatastoreStatus)
-> (DatastoreFilter -> Maybe DatastoreStatus -> DatastoreFilter)
-> Lens
     DatastoreFilter
     DatastoreFilter
     (Maybe DatastoreStatus)
     (Maybe DatastoreStatus)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DatastoreFilter' {Maybe DatastoreStatus
datastoreStatus :: Maybe DatastoreStatus
$sel:datastoreStatus:DatastoreFilter' :: DatastoreFilter -> Maybe DatastoreStatus
datastoreStatus} -> Maybe DatastoreStatus
datastoreStatus) (\s :: DatastoreFilter
s@DatastoreFilter' {} Maybe DatastoreStatus
a -> DatastoreFilter
s {$sel:datastoreStatus:DatastoreFilter' :: Maybe DatastoreStatus
datastoreStatus = Maybe DatastoreStatus
a} :: DatastoreFilter)

-- | A filter that allows the user to set cutoff dates for records. All Data
-- Stores created before the specified date will be included in the
-- results.
datastoreFilter_createdBefore :: Lens.Lens' DatastoreFilter (Prelude.Maybe Prelude.UTCTime)
datastoreFilter_createdBefore :: (Maybe UTCTime -> f (Maybe UTCTime))
-> DatastoreFilter -> f DatastoreFilter
datastoreFilter_createdBefore = (DatastoreFilter -> Maybe POSIX)
-> (DatastoreFilter -> Maybe POSIX -> DatastoreFilter)
-> Lens DatastoreFilter DatastoreFilter (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DatastoreFilter' {Maybe POSIX
createdBefore :: Maybe POSIX
$sel:createdBefore:DatastoreFilter' :: DatastoreFilter -> Maybe POSIX
createdBefore} -> Maybe POSIX
createdBefore) (\s :: DatastoreFilter
s@DatastoreFilter' {} Maybe POSIX
a -> DatastoreFilter
s {$sel:createdBefore:DatastoreFilter' :: Maybe POSIX
createdBefore = Maybe POSIX
a} :: DatastoreFilter) ((Maybe POSIX -> f (Maybe POSIX))
 -> DatastoreFilter -> f DatastoreFilter)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> DatastoreFilter
-> f DatastoreFilter
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
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 AnIso POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

instance Prelude.Hashable DatastoreFilter

instance Prelude.NFData DatastoreFilter

instance Core.ToJSON DatastoreFilter where
  toJSON :: DatastoreFilter -> Value
toJSON DatastoreFilter' {Maybe Text
Maybe POSIX
Maybe DatastoreStatus
createdBefore :: Maybe POSIX
datastoreStatus :: Maybe DatastoreStatus
datastoreName :: Maybe Text
createdAfter :: Maybe POSIX
$sel:createdBefore:DatastoreFilter' :: DatastoreFilter -> Maybe POSIX
$sel:datastoreStatus:DatastoreFilter' :: DatastoreFilter -> Maybe DatastoreStatus
$sel:datastoreName:DatastoreFilter' :: DatastoreFilter -> Maybe Text
$sel:createdAfter:DatastoreFilter' :: DatastoreFilter -> Maybe POSIX
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"CreatedAfter" Text -> POSIX -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (POSIX -> Pair) -> Maybe POSIX -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe POSIX
createdAfter,
            (Text
"DatastoreName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
datastoreName,
            (Text
"DatastoreStatus" Text -> DatastoreStatus -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (DatastoreStatus -> Pair) -> Maybe DatastoreStatus -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe DatastoreStatus
datastoreStatus,
            (Text
"CreatedBefore" Text -> POSIX -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (POSIX -> Pair) -> Maybe POSIX -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe POSIX
createdBefore
          ]
      )