{-# 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.QuickSight.CreateGroupMembership
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Adds an Amazon QuickSight user to an Amazon QuickSight group.
module Amazonka.QuickSight.CreateGroupMembership
  ( -- * Creating a Request
    CreateGroupMembership (..),
    newCreateGroupMembership,

    -- * Request Lenses
    createGroupMembership_memberName,
    createGroupMembership_groupName,
    createGroupMembership_awsAccountId,
    createGroupMembership_namespace,

    -- * Destructuring the Response
    CreateGroupMembershipResponse (..),
    newCreateGroupMembershipResponse,

    -- * Response Lenses
    createGroupMembershipResponse_groupMember,
    createGroupMembershipResponse_requestId,
    createGroupMembershipResponse_status,
  )
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
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateGroupMembership' smart constructor.
data CreateGroupMembership = CreateGroupMembership'
  { -- | The name of the user that you want to add to the group membership.
    CreateGroupMembership -> Text
memberName :: Prelude.Text,
    -- | The name of the group that you want to add the user to.
    CreateGroupMembership -> Text
groupName :: Prelude.Text,
    -- | The ID for the Amazon Web Services account that the group is in.
    -- Currently, you use the ID for the Amazon Web Services account that
    -- contains your Amazon QuickSight account.
    CreateGroupMembership -> Text
awsAccountId :: Prelude.Text,
    -- | The namespace that you want the user to be a part of.
    CreateGroupMembership -> Text
namespace :: Prelude.Text
  }
  deriving (CreateGroupMembership -> CreateGroupMembership -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateGroupMembership -> CreateGroupMembership -> Bool
$c/= :: CreateGroupMembership -> CreateGroupMembership -> Bool
== :: CreateGroupMembership -> CreateGroupMembership -> Bool
$c== :: CreateGroupMembership -> CreateGroupMembership -> Bool
Prelude.Eq, ReadPrec [CreateGroupMembership]
ReadPrec CreateGroupMembership
Int -> ReadS CreateGroupMembership
ReadS [CreateGroupMembership]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateGroupMembership]
$creadListPrec :: ReadPrec [CreateGroupMembership]
readPrec :: ReadPrec CreateGroupMembership
$creadPrec :: ReadPrec CreateGroupMembership
readList :: ReadS [CreateGroupMembership]
$creadList :: ReadS [CreateGroupMembership]
readsPrec :: Int -> ReadS CreateGroupMembership
$creadsPrec :: Int -> ReadS CreateGroupMembership
Prelude.Read, Int -> CreateGroupMembership -> ShowS
[CreateGroupMembership] -> ShowS
CreateGroupMembership -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateGroupMembership] -> ShowS
$cshowList :: [CreateGroupMembership] -> ShowS
show :: CreateGroupMembership -> String
$cshow :: CreateGroupMembership -> String
showsPrec :: Int -> CreateGroupMembership -> ShowS
$cshowsPrec :: Int -> CreateGroupMembership -> ShowS
Prelude.Show, forall x. Rep CreateGroupMembership x -> CreateGroupMembership
forall x. CreateGroupMembership -> Rep CreateGroupMembership x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateGroupMembership x -> CreateGroupMembership
$cfrom :: forall x. CreateGroupMembership -> Rep CreateGroupMembership x
Prelude.Generic)

-- |
-- Create a value of 'CreateGroupMembership' 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:
--
-- 'memberName', 'createGroupMembership_memberName' - The name of the user that you want to add to the group membership.
--
-- 'groupName', 'createGroupMembership_groupName' - The name of the group that you want to add the user to.
--
-- 'awsAccountId', 'createGroupMembership_awsAccountId' - The ID for the Amazon Web Services account that the group is in.
-- Currently, you use the ID for the Amazon Web Services account that
-- contains your Amazon QuickSight account.
--
-- 'namespace', 'createGroupMembership_namespace' - The namespace that you want the user to be a part of.
newCreateGroupMembership ::
  -- | 'memberName'
  Prelude.Text ->
  -- | 'groupName'
  Prelude.Text ->
  -- | 'awsAccountId'
  Prelude.Text ->
  -- | 'namespace'
  Prelude.Text ->
  CreateGroupMembership
newCreateGroupMembership :: Text -> Text -> Text -> Text -> CreateGroupMembership
newCreateGroupMembership
  Text
pMemberName_
  Text
pGroupName_
  Text
pAwsAccountId_
  Text
pNamespace_ =
    CreateGroupMembership'
      { $sel:memberName:CreateGroupMembership' :: Text
memberName = Text
pMemberName_,
        $sel:groupName:CreateGroupMembership' :: Text
groupName = Text
pGroupName_,
        $sel:awsAccountId:CreateGroupMembership' :: Text
awsAccountId = Text
pAwsAccountId_,
        $sel:namespace:CreateGroupMembership' :: Text
namespace = Text
pNamespace_
      }

-- | The name of the user that you want to add to the group membership.
createGroupMembership_memberName :: Lens.Lens' CreateGroupMembership Prelude.Text
createGroupMembership_memberName :: Lens' CreateGroupMembership Text
createGroupMembership_memberName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGroupMembership' {Text
memberName :: Text
$sel:memberName:CreateGroupMembership' :: CreateGroupMembership -> Text
memberName} -> Text
memberName) (\s :: CreateGroupMembership
s@CreateGroupMembership' {} Text
a -> CreateGroupMembership
s {$sel:memberName:CreateGroupMembership' :: Text
memberName = Text
a} :: CreateGroupMembership)

-- | The name of the group that you want to add the user to.
createGroupMembership_groupName :: Lens.Lens' CreateGroupMembership Prelude.Text
createGroupMembership_groupName :: Lens' CreateGroupMembership Text
createGroupMembership_groupName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGroupMembership' {Text
groupName :: Text
$sel:groupName:CreateGroupMembership' :: CreateGroupMembership -> Text
groupName} -> Text
groupName) (\s :: CreateGroupMembership
s@CreateGroupMembership' {} Text
a -> CreateGroupMembership
s {$sel:groupName:CreateGroupMembership' :: Text
groupName = Text
a} :: CreateGroupMembership)

-- | The ID for the Amazon Web Services account that the group is in.
-- Currently, you use the ID for the Amazon Web Services account that
-- contains your Amazon QuickSight account.
createGroupMembership_awsAccountId :: Lens.Lens' CreateGroupMembership Prelude.Text
createGroupMembership_awsAccountId :: Lens' CreateGroupMembership Text
createGroupMembership_awsAccountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGroupMembership' {Text
awsAccountId :: Text
$sel:awsAccountId:CreateGroupMembership' :: CreateGroupMembership -> Text
awsAccountId} -> Text
awsAccountId) (\s :: CreateGroupMembership
s@CreateGroupMembership' {} Text
a -> CreateGroupMembership
s {$sel:awsAccountId:CreateGroupMembership' :: Text
awsAccountId = Text
a} :: CreateGroupMembership)

-- | The namespace that you want the user to be a part of.
createGroupMembership_namespace :: Lens.Lens' CreateGroupMembership Prelude.Text
createGroupMembership_namespace :: Lens' CreateGroupMembership Text
createGroupMembership_namespace = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGroupMembership' {Text
namespace :: Text
$sel:namespace:CreateGroupMembership' :: CreateGroupMembership -> Text
namespace} -> Text
namespace) (\s :: CreateGroupMembership
s@CreateGroupMembership' {} Text
a -> CreateGroupMembership
s {$sel:namespace:CreateGroupMembership' :: Text
namespace = Text
a} :: CreateGroupMembership)

instance Core.AWSRequest CreateGroupMembership where
  type
    AWSResponse CreateGroupMembership =
      CreateGroupMembershipResponse
  request :: (Service -> Service)
-> CreateGroupMembership -> Request CreateGroupMembership
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.putJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy CreateGroupMembership
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateGroupMembership)))
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 ->
          Maybe GroupMember
-> Maybe Text -> Int -> CreateGroupMembershipResponse
CreateGroupMembershipResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"GroupMember")
            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
"RequestId")
            forall (f :: * -> *) a b. Applicative f => 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))
      )

instance Prelude.Hashable CreateGroupMembership where
  hashWithSalt :: Int -> CreateGroupMembership -> Int
hashWithSalt Int
_salt CreateGroupMembership' {Text
namespace :: Text
awsAccountId :: Text
groupName :: Text
memberName :: Text
$sel:namespace:CreateGroupMembership' :: CreateGroupMembership -> Text
$sel:awsAccountId:CreateGroupMembership' :: CreateGroupMembership -> Text
$sel:groupName:CreateGroupMembership' :: CreateGroupMembership -> Text
$sel:memberName:CreateGroupMembership' :: CreateGroupMembership -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
memberName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
groupName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
awsAccountId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
namespace

instance Prelude.NFData CreateGroupMembership where
  rnf :: CreateGroupMembership -> ()
rnf CreateGroupMembership' {Text
namespace :: Text
awsAccountId :: Text
groupName :: Text
memberName :: Text
$sel:namespace:CreateGroupMembership' :: CreateGroupMembership -> Text
$sel:awsAccountId:CreateGroupMembership' :: CreateGroupMembership -> Text
$sel:groupName:CreateGroupMembership' :: CreateGroupMembership -> Text
$sel:memberName:CreateGroupMembership' :: CreateGroupMembership -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
memberName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
groupName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
awsAccountId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
namespace

instance Data.ToHeaders CreateGroupMembership where
  toHeaders :: CreateGroupMembership -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateGroupMembership where
  toJSON :: CreateGroupMembership -> Value
toJSON = forall a b. a -> b -> a
Prelude.const (Object -> Value
Data.Object forall a. Monoid a => a
Prelude.mempty)

instance Data.ToPath CreateGroupMembership where
  toPath :: CreateGroupMembership -> ByteString
toPath CreateGroupMembership' {Text
namespace :: Text
awsAccountId :: Text
groupName :: Text
memberName :: Text
$sel:namespace:CreateGroupMembership' :: CreateGroupMembership -> Text
$sel:awsAccountId:CreateGroupMembership' :: CreateGroupMembership -> Text
$sel:groupName:CreateGroupMembership' :: CreateGroupMembership -> Text
$sel:memberName:CreateGroupMembership' :: CreateGroupMembership -> Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/accounts/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
awsAccountId,
        ByteString
"/namespaces/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
namespace,
        ByteString
"/groups/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
groupName,
        ByteString
"/members/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
memberName
      ]

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

-- | /See:/ 'newCreateGroupMembershipResponse' smart constructor.
data CreateGroupMembershipResponse = CreateGroupMembershipResponse'
  { -- | The group member.
    CreateGroupMembershipResponse -> Maybe GroupMember
groupMember :: Prelude.Maybe GroupMember,
    -- | The Amazon Web Services request ID for this operation.
    CreateGroupMembershipResponse -> Maybe Text
requestId :: Prelude.Maybe Prelude.Text,
    -- | The HTTP status of the request.
    CreateGroupMembershipResponse -> Int
status :: Prelude.Int
  }
  deriving (CreateGroupMembershipResponse
-> CreateGroupMembershipResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateGroupMembershipResponse
-> CreateGroupMembershipResponse -> Bool
$c/= :: CreateGroupMembershipResponse
-> CreateGroupMembershipResponse -> Bool
== :: CreateGroupMembershipResponse
-> CreateGroupMembershipResponse -> Bool
$c== :: CreateGroupMembershipResponse
-> CreateGroupMembershipResponse -> Bool
Prelude.Eq, ReadPrec [CreateGroupMembershipResponse]
ReadPrec CreateGroupMembershipResponse
Int -> ReadS CreateGroupMembershipResponse
ReadS [CreateGroupMembershipResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateGroupMembershipResponse]
$creadListPrec :: ReadPrec [CreateGroupMembershipResponse]
readPrec :: ReadPrec CreateGroupMembershipResponse
$creadPrec :: ReadPrec CreateGroupMembershipResponse
readList :: ReadS [CreateGroupMembershipResponse]
$creadList :: ReadS [CreateGroupMembershipResponse]
readsPrec :: Int -> ReadS CreateGroupMembershipResponse
$creadsPrec :: Int -> ReadS CreateGroupMembershipResponse
Prelude.Read, Int -> CreateGroupMembershipResponse -> ShowS
[CreateGroupMembershipResponse] -> ShowS
CreateGroupMembershipResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateGroupMembershipResponse] -> ShowS
$cshowList :: [CreateGroupMembershipResponse] -> ShowS
show :: CreateGroupMembershipResponse -> String
$cshow :: CreateGroupMembershipResponse -> String
showsPrec :: Int -> CreateGroupMembershipResponse -> ShowS
$cshowsPrec :: Int -> CreateGroupMembershipResponse -> ShowS
Prelude.Show, forall x.
Rep CreateGroupMembershipResponse x
-> CreateGroupMembershipResponse
forall x.
CreateGroupMembershipResponse
-> Rep CreateGroupMembershipResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateGroupMembershipResponse x
-> CreateGroupMembershipResponse
$cfrom :: forall x.
CreateGroupMembershipResponse
-> Rep CreateGroupMembershipResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateGroupMembershipResponse' 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:
--
-- 'groupMember', 'createGroupMembershipResponse_groupMember' - The group member.
--
-- 'requestId', 'createGroupMembershipResponse_requestId' - The Amazon Web Services request ID for this operation.
--
-- 'status', 'createGroupMembershipResponse_status' - The HTTP status of the request.
newCreateGroupMembershipResponse ::
  -- | 'status'
  Prelude.Int ->
  CreateGroupMembershipResponse
newCreateGroupMembershipResponse :: Int -> CreateGroupMembershipResponse
newCreateGroupMembershipResponse Int
pStatus_ =
  CreateGroupMembershipResponse'
    { $sel:groupMember:CreateGroupMembershipResponse' :: Maybe GroupMember
groupMember =
        forall a. Maybe a
Prelude.Nothing,
      $sel:requestId:CreateGroupMembershipResponse' :: Maybe Text
requestId = forall a. Maybe a
Prelude.Nothing,
      $sel:status:CreateGroupMembershipResponse' :: Int
status = Int
pStatus_
    }

-- | The group member.
createGroupMembershipResponse_groupMember :: Lens.Lens' CreateGroupMembershipResponse (Prelude.Maybe GroupMember)
createGroupMembershipResponse_groupMember :: Lens' CreateGroupMembershipResponse (Maybe GroupMember)
createGroupMembershipResponse_groupMember = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGroupMembershipResponse' {Maybe GroupMember
groupMember :: Maybe GroupMember
$sel:groupMember:CreateGroupMembershipResponse' :: CreateGroupMembershipResponse -> Maybe GroupMember
groupMember} -> Maybe GroupMember
groupMember) (\s :: CreateGroupMembershipResponse
s@CreateGroupMembershipResponse' {} Maybe GroupMember
a -> CreateGroupMembershipResponse
s {$sel:groupMember:CreateGroupMembershipResponse' :: Maybe GroupMember
groupMember = Maybe GroupMember
a} :: CreateGroupMembershipResponse)

-- | The Amazon Web Services request ID for this operation.
createGroupMembershipResponse_requestId :: Lens.Lens' CreateGroupMembershipResponse (Prelude.Maybe Prelude.Text)
createGroupMembershipResponse_requestId :: Lens' CreateGroupMembershipResponse (Maybe Text)
createGroupMembershipResponse_requestId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGroupMembershipResponse' {Maybe Text
requestId :: Maybe Text
$sel:requestId:CreateGroupMembershipResponse' :: CreateGroupMembershipResponse -> Maybe Text
requestId} -> Maybe Text
requestId) (\s :: CreateGroupMembershipResponse
s@CreateGroupMembershipResponse' {} Maybe Text
a -> CreateGroupMembershipResponse
s {$sel:requestId:CreateGroupMembershipResponse' :: Maybe Text
requestId = Maybe Text
a} :: CreateGroupMembershipResponse)

-- | The HTTP status of the request.
createGroupMembershipResponse_status :: Lens.Lens' CreateGroupMembershipResponse Prelude.Int
createGroupMembershipResponse_status :: Lens' CreateGroupMembershipResponse Int
createGroupMembershipResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateGroupMembershipResponse' {Int
status :: Int
$sel:status:CreateGroupMembershipResponse' :: CreateGroupMembershipResponse -> Int
status} -> Int
status) (\s :: CreateGroupMembershipResponse
s@CreateGroupMembershipResponse' {} Int
a -> CreateGroupMembershipResponse
s {$sel:status:CreateGroupMembershipResponse' :: Int
status = Int
a} :: CreateGroupMembershipResponse)

instance Prelude.NFData CreateGroupMembershipResponse where
  rnf :: CreateGroupMembershipResponse -> ()
rnf CreateGroupMembershipResponse' {Int
Maybe Text
Maybe GroupMember
status :: Int
requestId :: Maybe Text
groupMember :: Maybe GroupMember
$sel:status:CreateGroupMembershipResponse' :: CreateGroupMembershipResponse -> Int
$sel:requestId:CreateGroupMembershipResponse' :: CreateGroupMembershipResponse -> Maybe Text
$sel:groupMember:CreateGroupMembershipResponse' :: CreateGroupMembershipResponse -> Maybe GroupMember
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe GroupMember
groupMember
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
requestId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
status