{-# 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.Kendra.Types.GroupMembers
-- 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.Kendra.Types.GroupMembers where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Kendra.Types.MemberGroup
import Amazonka.Kendra.Types.MemberUser
import Amazonka.Kendra.Types.S3Path
import qualified Amazonka.Prelude as Prelude

-- | A list of users or sub groups that belong to a group. This is useful for
-- user context filtering, where search results are filtered based on the
-- user or their group access to documents.
--
-- /See:/ 'newGroupMembers' smart constructor.
data GroupMembers = GroupMembers'
  { -- | A list of sub groups that belong to a group. For example, the sub groups
    -- \"Research\", \"Engineering\", and \"Sales and Marketing\" all belong to
    -- the group \"Company\".
    GroupMembers -> Maybe (NonEmpty MemberGroup)
memberGroups :: Prelude.Maybe (Prelude.NonEmpty MemberGroup),
    -- | A list of users that belong to a group. For example, a list of interns
    -- all belong to the \"Interns\" group.
    GroupMembers -> Maybe (NonEmpty MemberUser)
memberUsers :: Prelude.Maybe (Prelude.NonEmpty MemberUser),
    -- | If you have more than 1000 users and\/or sub groups for a single group,
    -- you need to provide the path to the S3 file that lists your users and
    -- sub groups for a group. Your sub groups can contain more than 1000
    -- users, but the list of sub groups that belong to a group (and\/or users)
    -- must be no more than 1000.
    --
    -- You can download this
    -- <https://docs.aws.amazon.com/kendra/latest/dg/samples/group_members.zip example S3 file>
    -- that uses the correct format for listing group members. Note,
    -- @dataSourceId@ is optional. The value of @type@ for a group is always
    -- @GROUP@ and for a user it is always @USER@.
    GroupMembers -> Maybe S3Path
s3PathforGroupMembers :: Prelude.Maybe S3Path
  }
  deriving (GroupMembers -> GroupMembers -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GroupMembers -> GroupMembers -> Bool
$c/= :: GroupMembers -> GroupMembers -> Bool
== :: GroupMembers -> GroupMembers -> Bool
$c== :: GroupMembers -> GroupMembers -> Bool
Prelude.Eq, ReadPrec [GroupMembers]
ReadPrec GroupMembers
Int -> ReadS GroupMembers
ReadS [GroupMembers]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GroupMembers]
$creadListPrec :: ReadPrec [GroupMembers]
readPrec :: ReadPrec GroupMembers
$creadPrec :: ReadPrec GroupMembers
readList :: ReadS [GroupMembers]
$creadList :: ReadS [GroupMembers]
readsPrec :: Int -> ReadS GroupMembers
$creadsPrec :: Int -> ReadS GroupMembers
Prelude.Read, Int -> GroupMembers -> ShowS
[GroupMembers] -> ShowS
GroupMembers -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GroupMembers] -> ShowS
$cshowList :: [GroupMembers] -> ShowS
show :: GroupMembers -> String
$cshow :: GroupMembers -> String
showsPrec :: Int -> GroupMembers -> ShowS
$cshowsPrec :: Int -> GroupMembers -> ShowS
Prelude.Show, forall x. Rep GroupMembers x -> GroupMembers
forall x. GroupMembers -> Rep GroupMembers x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GroupMembers x -> GroupMembers
$cfrom :: forall x. GroupMembers -> Rep GroupMembers x
Prelude.Generic)

-- |
-- Create a value of 'GroupMembers' 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:
--
-- 'memberGroups', 'groupMembers_memberGroups' - A list of sub groups that belong to a group. For example, the sub groups
-- \"Research\", \"Engineering\", and \"Sales and Marketing\" all belong to
-- the group \"Company\".
--
-- 'memberUsers', 'groupMembers_memberUsers' - A list of users that belong to a group. For example, a list of interns
-- all belong to the \"Interns\" group.
--
-- 's3PathforGroupMembers', 'groupMembers_s3PathforGroupMembers' - If you have more than 1000 users and\/or sub groups for a single group,
-- you need to provide the path to the S3 file that lists your users and
-- sub groups for a group. Your sub groups can contain more than 1000
-- users, but the list of sub groups that belong to a group (and\/or users)
-- must be no more than 1000.
--
-- You can download this
-- <https://docs.aws.amazon.com/kendra/latest/dg/samples/group_members.zip example S3 file>
-- that uses the correct format for listing group members. Note,
-- @dataSourceId@ is optional. The value of @type@ for a group is always
-- @GROUP@ and for a user it is always @USER@.
newGroupMembers ::
  GroupMembers
newGroupMembers :: GroupMembers
newGroupMembers =
  GroupMembers'
    { $sel:memberGroups:GroupMembers' :: Maybe (NonEmpty MemberGroup)
memberGroups = forall a. Maybe a
Prelude.Nothing,
      $sel:memberUsers:GroupMembers' :: Maybe (NonEmpty MemberUser)
memberUsers = forall a. Maybe a
Prelude.Nothing,
      $sel:s3PathforGroupMembers:GroupMembers' :: Maybe S3Path
s3PathforGroupMembers = forall a. Maybe a
Prelude.Nothing
    }

-- | A list of sub groups that belong to a group. For example, the sub groups
-- \"Research\", \"Engineering\", and \"Sales and Marketing\" all belong to
-- the group \"Company\".
groupMembers_memberGroups :: Lens.Lens' GroupMembers (Prelude.Maybe (Prelude.NonEmpty MemberGroup))
groupMembers_memberGroups :: Lens' GroupMembers (Maybe (NonEmpty MemberGroup))
groupMembers_memberGroups = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GroupMembers' {Maybe (NonEmpty MemberGroup)
memberGroups :: Maybe (NonEmpty MemberGroup)
$sel:memberGroups:GroupMembers' :: GroupMembers -> Maybe (NonEmpty MemberGroup)
memberGroups} -> Maybe (NonEmpty MemberGroup)
memberGroups) (\s :: GroupMembers
s@GroupMembers' {} Maybe (NonEmpty MemberGroup)
a -> GroupMembers
s {$sel:memberGroups:GroupMembers' :: Maybe (NonEmpty MemberGroup)
memberGroups = Maybe (NonEmpty MemberGroup)
a} :: GroupMembers) 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 list of users that belong to a group. For example, a list of interns
-- all belong to the \"Interns\" group.
groupMembers_memberUsers :: Lens.Lens' GroupMembers (Prelude.Maybe (Prelude.NonEmpty MemberUser))
groupMembers_memberUsers :: Lens' GroupMembers (Maybe (NonEmpty MemberUser))
groupMembers_memberUsers = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GroupMembers' {Maybe (NonEmpty MemberUser)
memberUsers :: Maybe (NonEmpty MemberUser)
$sel:memberUsers:GroupMembers' :: GroupMembers -> Maybe (NonEmpty MemberUser)
memberUsers} -> Maybe (NonEmpty MemberUser)
memberUsers) (\s :: GroupMembers
s@GroupMembers' {} Maybe (NonEmpty MemberUser)
a -> GroupMembers
s {$sel:memberUsers:GroupMembers' :: Maybe (NonEmpty MemberUser)
memberUsers = Maybe (NonEmpty MemberUser)
a} :: GroupMembers) 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

-- | If you have more than 1000 users and\/or sub groups for a single group,
-- you need to provide the path to the S3 file that lists your users and
-- sub groups for a group. Your sub groups can contain more than 1000
-- users, but the list of sub groups that belong to a group (and\/or users)
-- must be no more than 1000.
--
-- You can download this
-- <https://docs.aws.amazon.com/kendra/latest/dg/samples/group_members.zip example S3 file>
-- that uses the correct format for listing group members. Note,
-- @dataSourceId@ is optional. The value of @type@ for a group is always
-- @GROUP@ and for a user it is always @USER@.
groupMembers_s3PathforGroupMembers :: Lens.Lens' GroupMembers (Prelude.Maybe S3Path)
groupMembers_s3PathforGroupMembers :: Lens' GroupMembers (Maybe S3Path)
groupMembers_s3PathforGroupMembers = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GroupMembers' {Maybe S3Path
s3PathforGroupMembers :: Maybe S3Path
$sel:s3PathforGroupMembers:GroupMembers' :: GroupMembers -> Maybe S3Path
s3PathforGroupMembers} -> Maybe S3Path
s3PathforGroupMembers) (\s :: GroupMembers
s@GroupMembers' {} Maybe S3Path
a -> GroupMembers
s {$sel:s3PathforGroupMembers:GroupMembers' :: Maybe S3Path
s3PathforGroupMembers = Maybe S3Path
a} :: GroupMembers)

instance Prelude.Hashable GroupMembers where
  hashWithSalt :: Int -> GroupMembers -> Int
hashWithSalt Int
_salt GroupMembers' {Maybe (NonEmpty MemberGroup)
Maybe (NonEmpty MemberUser)
Maybe S3Path
s3PathforGroupMembers :: Maybe S3Path
memberUsers :: Maybe (NonEmpty MemberUser)
memberGroups :: Maybe (NonEmpty MemberGroup)
$sel:s3PathforGroupMembers:GroupMembers' :: GroupMembers -> Maybe S3Path
$sel:memberUsers:GroupMembers' :: GroupMembers -> Maybe (NonEmpty MemberUser)
$sel:memberGroups:GroupMembers' :: GroupMembers -> Maybe (NonEmpty MemberGroup)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty MemberGroup)
memberGroups
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty MemberUser)
memberUsers
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe S3Path
s3PathforGroupMembers

instance Prelude.NFData GroupMembers where
  rnf :: GroupMembers -> ()
rnf GroupMembers' {Maybe (NonEmpty MemberGroup)
Maybe (NonEmpty MemberUser)
Maybe S3Path
s3PathforGroupMembers :: Maybe S3Path
memberUsers :: Maybe (NonEmpty MemberUser)
memberGroups :: Maybe (NonEmpty MemberGroup)
$sel:s3PathforGroupMembers:GroupMembers' :: GroupMembers -> Maybe S3Path
$sel:memberUsers:GroupMembers' :: GroupMembers -> Maybe (NonEmpty MemberUser)
$sel:memberGroups:GroupMembers' :: GroupMembers -> Maybe (NonEmpty MemberGroup)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty MemberGroup)
memberGroups
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty MemberUser)
memberUsers
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe S3Path
s3PathforGroupMembers

instance Data.ToJSON GroupMembers where
  toJSON :: GroupMembers -> Value
toJSON GroupMembers' {Maybe (NonEmpty MemberGroup)
Maybe (NonEmpty MemberUser)
Maybe S3Path
s3PathforGroupMembers :: Maybe S3Path
memberUsers :: Maybe (NonEmpty MemberUser)
memberGroups :: Maybe (NonEmpty MemberGroup)
$sel:s3PathforGroupMembers:GroupMembers' :: GroupMembers -> Maybe S3Path
$sel:memberUsers:GroupMembers' :: GroupMembers -> Maybe (NonEmpty MemberUser)
$sel:memberGroups:GroupMembers' :: GroupMembers -> Maybe (NonEmpty MemberGroup)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"MemberGroups" 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 (NonEmpty MemberGroup)
memberGroups,
            (Key
"MemberUsers" 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 (NonEmpty MemberUser)
memberUsers,
            (Key
"S3PathforGroupMembers" 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 S3Path
s3PathforGroupMembers
          ]
      )