{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.IdentityStore.IsMemberInGroups
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Checks the user\'s membership in all requested groups and returns if the
-- member exists in all queried groups.
module Amazonka.IdentityStore.IsMemberInGroups
  ( -- * Creating a Request
    IsMemberInGroups (..),
    newIsMemberInGroups,

    -- * Request Lenses
    isMemberInGroups_identityStoreId,
    isMemberInGroups_memberId,
    isMemberInGroups_groupIds,

    -- * Destructuring the Response
    IsMemberInGroupsResponse (..),
    newIsMemberInGroupsResponse,

    -- * Response Lenses
    isMemberInGroupsResponse_httpStatus,
    isMemberInGroupsResponse_results,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.IdentityStore.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newIsMemberInGroups' smart constructor.
data IsMemberInGroups = IsMemberInGroups'
  { -- | The globally unique identifier for the identity store.
    IsMemberInGroups -> Text
identityStoreId :: Prelude.Text,
    -- | An object containing the identifier of a group member.
    IsMemberInGroups -> MemberId
memberId :: MemberId,
    -- | A list of identifiers for groups in the identity store.
    IsMemberInGroups -> NonEmpty Text
groupIds :: Prelude.NonEmpty Prelude.Text
  }
  deriving (IsMemberInGroups -> IsMemberInGroups -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IsMemberInGroups -> IsMemberInGroups -> Bool
$c/= :: IsMemberInGroups -> IsMemberInGroups -> Bool
== :: IsMemberInGroups -> IsMemberInGroups -> Bool
$c== :: IsMemberInGroups -> IsMemberInGroups -> Bool
Prelude.Eq, ReadPrec [IsMemberInGroups]
ReadPrec IsMemberInGroups
Int -> ReadS IsMemberInGroups
ReadS [IsMemberInGroups]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IsMemberInGroups]
$creadListPrec :: ReadPrec [IsMemberInGroups]
readPrec :: ReadPrec IsMemberInGroups
$creadPrec :: ReadPrec IsMemberInGroups
readList :: ReadS [IsMemberInGroups]
$creadList :: ReadS [IsMemberInGroups]
readsPrec :: Int -> ReadS IsMemberInGroups
$creadsPrec :: Int -> ReadS IsMemberInGroups
Prelude.Read, Int -> IsMemberInGroups -> ShowS
[IsMemberInGroups] -> ShowS
IsMemberInGroups -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IsMemberInGroups] -> ShowS
$cshowList :: [IsMemberInGroups] -> ShowS
show :: IsMemberInGroups -> String
$cshow :: IsMemberInGroups -> String
showsPrec :: Int -> IsMemberInGroups -> ShowS
$cshowsPrec :: Int -> IsMemberInGroups -> ShowS
Prelude.Show, forall x. Rep IsMemberInGroups x -> IsMemberInGroups
forall x. IsMemberInGroups -> Rep IsMemberInGroups x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep IsMemberInGroups x -> IsMemberInGroups
$cfrom :: forall x. IsMemberInGroups -> Rep IsMemberInGroups x
Prelude.Generic)

-- |
-- Create a value of 'IsMemberInGroups' 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:
--
-- 'identityStoreId', 'isMemberInGroups_identityStoreId' - The globally unique identifier for the identity store.
--
-- 'memberId', 'isMemberInGroups_memberId' - An object containing the identifier of a group member.
--
-- 'groupIds', 'isMemberInGroups_groupIds' - A list of identifiers for groups in the identity store.
newIsMemberInGroups ::
  -- | 'identityStoreId'
  Prelude.Text ->
  -- | 'memberId'
  MemberId ->
  -- | 'groupIds'
  Prelude.NonEmpty Prelude.Text ->
  IsMemberInGroups
newIsMemberInGroups :: Text -> MemberId -> NonEmpty Text -> IsMemberInGroups
newIsMemberInGroups
  Text
pIdentityStoreId_
  MemberId
pMemberId_
  NonEmpty Text
pGroupIds_ =
    IsMemberInGroups'
      { $sel:identityStoreId:IsMemberInGroups' :: Text
identityStoreId =
          Text
pIdentityStoreId_,
        $sel:memberId:IsMemberInGroups' :: MemberId
memberId = MemberId
pMemberId_,
        $sel:groupIds:IsMemberInGroups' :: NonEmpty Text
groupIds = 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 Text
pGroupIds_
      }

-- | The globally unique identifier for the identity store.
isMemberInGroups_identityStoreId :: Lens.Lens' IsMemberInGroups Prelude.Text
isMemberInGroups_identityStoreId :: Lens' IsMemberInGroups Text
isMemberInGroups_identityStoreId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\IsMemberInGroups' {Text
identityStoreId :: Text
$sel:identityStoreId:IsMemberInGroups' :: IsMemberInGroups -> Text
identityStoreId} -> Text
identityStoreId) (\s :: IsMemberInGroups
s@IsMemberInGroups' {} Text
a -> IsMemberInGroups
s {$sel:identityStoreId:IsMemberInGroups' :: Text
identityStoreId = Text
a} :: IsMemberInGroups)

-- | An object containing the identifier of a group member.
isMemberInGroups_memberId :: Lens.Lens' IsMemberInGroups MemberId
isMemberInGroups_memberId :: Lens' IsMemberInGroups MemberId
isMemberInGroups_memberId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\IsMemberInGroups' {MemberId
memberId :: MemberId
$sel:memberId:IsMemberInGroups' :: IsMemberInGroups -> MemberId
memberId} -> MemberId
memberId) (\s :: IsMemberInGroups
s@IsMemberInGroups' {} MemberId
a -> IsMemberInGroups
s {$sel:memberId:IsMemberInGroups' :: MemberId
memberId = MemberId
a} :: IsMemberInGroups)

-- | A list of identifiers for groups in the identity store.
isMemberInGroups_groupIds :: Lens.Lens' IsMemberInGroups (Prelude.NonEmpty Prelude.Text)
isMemberInGroups_groupIds :: Lens' IsMemberInGroups (NonEmpty Text)
isMemberInGroups_groupIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\IsMemberInGroups' {NonEmpty Text
groupIds :: NonEmpty Text
$sel:groupIds:IsMemberInGroups' :: IsMemberInGroups -> NonEmpty Text
groupIds} -> NonEmpty Text
groupIds) (\s :: IsMemberInGroups
s@IsMemberInGroups' {} NonEmpty Text
a -> IsMemberInGroups
s {$sel:groupIds:IsMemberInGroups' :: NonEmpty Text
groupIds = NonEmpty Text
a} :: IsMemberInGroups) 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 Core.AWSRequest IsMemberInGroups where
  type
    AWSResponse IsMemberInGroups =
      IsMemberInGroupsResponse
  request :: (Service -> Service)
-> IsMemberInGroups -> Request IsMemberInGroups
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy IsMemberInGroups
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse IsMemberInGroups)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Int -> [GroupMembershipExistenceResult] -> IsMemberInGroupsResponse
IsMemberInGroupsResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Results" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
      )

instance Prelude.Hashable IsMemberInGroups where
  hashWithSalt :: Int -> IsMemberInGroups -> Int
hashWithSalt Int
_salt IsMemberInGroups' {NonEmpty Text
Text
MemberId
groupIds :: NonEmpty Text
memberId :: MemberId
identityStoreId :: Text
$sel:groupIds:IsMemberInGroups' :: IsMemberInGroups -> NonEmpty Text
$sel:memberId:IsMemberInGroups' :: IsMemberInGroups -> MemberId
$sel:identityStoreId:IsMemberInGroups' :: IsMemberInGroups -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
identityStoreId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` MemberId
memberId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty Text
groupIds

instance Prelude.NFData IsMemberInGroups where
  rnf :: IsMemberInGroups -> ()
rnf IsMemberInGroups' {NonEmpty Text
Text
MemberId
groupIds :: NonEmpty Text
memberId :: MemberId
identityStoreId :: Text
$sel:groupIds:IsMemberInGroups' :: IsMemberInGroups -> NonEmpty Text
$sel:memberId:IsMemberInGroups' :: IsMemberInGroups -> MemberId
$sel:identityStoreId:IsMemberInGroups' :: IsMemberInGroups -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
identityStoreId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf MemberId
memberId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty Text
groupIds

instance Data.ToHeaders IsMemberInGroups where
  toHeaders :: IsMemberInGroups -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"AWSIdentityStore.IsMemberInGroups" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON IsMemberInGroups where
  toJSON :: IsMemberInGroups -> Value
toJSON IsMemberInGroups' {NonEmpty Text
Text
MemberId
groupIds :: NonEmpty Text
memberId :: MemberId
identityStoreId :: Text
$sel:groupIds:IsMemberInGroups' :: IsMemberInGroups -> NonEmpty Text
$sel:memberId:IsMemberInGroups' :: IsMemberInGroups -> MemberId
$sel:identityStoreId:IsMemberInGroups' :: IsMemberInGroups -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just
              (Key
"IdentityStoreId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
identityStoreId),
            forall a. a -> Maybe a
Prelude.Just (Key
"MemberId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= MemberId
memberId),
            forall a. a -> Maybe a
Prelude.Just (Key
"GroupIds" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty Text
groupIds)
          ]
      )

instance Data.ToPath IsMemberInGroups where
  toPath :: IsMemberInGroups -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery IsMemberInGroups where
  toQuery :: IsMemberInGroups -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newIsMemberInGroupsResponse' smart constructor.
data IsMemberInGroupsResponse = IsMemberInGroupsResponse'
  { -- | The response's http status code.
    IsMemberInGroupsResponse -> Int
httpStatus :: Prelude.Int,
    -- | A list containing the results of membership existence checks.
    IsMemberInGroupsResponse -> [GroupMembershipExistenceResult]
results :: [GroupMembershipExistenceResult]
  }
  deriving (IsMemberInGroupsResponse -> IsMemberInGroupsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IsMemberInGroupsResponse -> IsMemberInGroupsResponse -> Bool
$c/= :: IsMemberInGroupsResponse -> IsMemberInGroupsResponse -> Bool
== :: IsMemberInGroupsResponse -> IsMemberInGroupsResponse -> Bool
$c== :: IsMemberInGroupsResponse -> IsMemberInGroupsResponse -> Bool
Prelude.Eq, Int -> IsMemberInGroupsResponse -> ShowS
[IsMemberInGroupsResponse] -> ShowS
IsMemberInGroupsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IsMemberInGroupsResponse] -> ShowS
$cshowList :: [IsMemberInGroupsResponse] -> ShowS
show :: IsMemberInGroupsResponse -> String
$cshow :: IsMemberInGroupsResponse -> String
showsPrec :: Int -> IsMemberInGroupsResponse -> ShowS
$cshowsPrec :: Int -> IsMemberInGroupsResponse -> ShowS
Prelude.Show, forall x.
Rep IsMemberInGroupsResponse x -> IsMemberInGroupsResponse
forall x.
IsMemberInGroupsResponse -> Rep IsMemberInGroupsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep IsMemberInGroupsResponse x -> IsMemberInGroupsResponse
$cfrom :: forall x.
IsMemberInGroupsResponse -> Rep IsMemberInGroupsResponse x
Prelude.Generic)

-- |
-- Create a value of 'IsMemberInGroupsResponse' 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:
--
-- 'httpStatus', 'isMemberInGroupsResponse_httpStatus' - The response's http status code.
--
-- 'results', 'isMemberInGroupsResponse_results' - A list containing the results of membership existence checks.
newIsMemberInGroupsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  IsMemberInGroupsResponse
newIsMemberInGroupsResponse :: Int -> IsMemberInGroupsResponse
newIsMemberInGroupsResponse Int
pHttpStatus_ =
  IsMemberInGroupsResponse'
    { $sel:httpStatus:IsMemberInGroupsResponse' :: Int
httpStatus =
        Int
pHttpStatus_,
      $sel:results:IsMemberInGroupsResponse' :: [GroupMembershipExistenceResult]
results = forall a. Monoid a => a
Prelude.mempty
    }

-- | The response's http status code.
isMemberInGroupsResponse_httpStatus :: Lens.Lens' IsMemberInGroupsResponse Prelude.Int
isMemberInGroupsResponse_httpStatus :: Lens' IsMemberInGroupsResponse Int
isMemberInGroupsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\IsMemberInGroupsResponse' {Int
httpStatus :: Int
$sel:httpStatus:IsMemberInGroupsResponse' :: IsMemberInGroupsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: IsMemberInGroupsResponse
s@IsMemberInGroupsResponse' {} Int
a -> IsMemberInGroupsResponse
s {$sel:httpStatus:IsMemberInGroupsResponse' :: Int
httpStatus = Int
a} :: IsMemberInGroupsResponse)

-- | A list containing the results of membership existence checks.
isMemberInGroupsResponse_results :: Lens.Lens' IsMemberInGroupsResponse [GroupMembershipExistenceResult]
isMemberInGroupsResponse_results :: Lens' IsMemberInGroupsResponse [GroupMembershipExistenceResult]
isMemberInGroupsResponse_results = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\IsMemberInGroupsResponse' {[GroupMembershipExistenceResult]
results :: [GroupMembershipExistenceResult]
$sel:results:IsMemberInGroupsResponse' :: IsMemberInGroupsResponse -> [GroupMembershipExistenceResult]
results} -> [GroupMembershipExistenceResult]
results) (\s :: IsMemberInGroupsResponse
s@IsMemberInGroupsResponse' {} [GroupMembershipExistenceResult]
a -> IsMemberInGroupsResponse
s {$sel:results:IsMemberInGroupsResponse' :: [GroupMembershipExistenceResult]
results = [GroupMembershipExistenceResult]
a} :: IsMemberInGroupsResponse) 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 Prelude.NFData IsMemberInGroupsResponse where
  rnf :: IsMemberInGroupsResponse -> ()
rnf IsMemberInGroupsResponse' {Int
[GroupMembershipExistenceResult]
results :: [GroupMembershipExistenceResult]
httpStatus :: Int
$sel:results:IsMemberInGroupsResponse' :: IsMemberInGroupsResponse -> [GroupMembershipExistenceResult]
$sel:httpStatus:IsMemberInGroupsResponse' :: IsMemberInGroupsResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [GroupMembershipExistenceResult]
results