{-# 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.ElastiCache.ModifyUser
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Changes user password(s) and\/or access string.
module Amazonka.ElastiCache.ModifyUser
  ( -- * Creating a Request
    ModifyUser (..),
    newModifyUser,

    -- * Request Lenses
    modifyUser_accessString,
    modifyUser_appendAccessString,
    modifyUser_authenticationMode,
    modifyUser_noPasswordRequired,
    modifyUser_passwords,
    modifyUser_userId,

    -- * Destructuring the Response
    User (..),
    newUser,

    -- * Response Lenses
    user_arn,
    user_accessString,
    user_authentication,
    user_engine,
    user_minimumEngineVersion,
    user_status,
    user_userGroupIds,
    user_userId,
    user_userName,
  )
where

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

-- | /See:/ 'newModifyUser' smart constructor.
data ModifyUser = ModifyUser'
  { -- | Access permissions string used for this user.
    ModifyUser -> Maybe Text
accessString :: Prelude.Maybe Prelude.Text,
    -- | Adds additional user permissions to the access string.
    ModifyUser -> Maybe Text
appendAccessString :: Prelude.Maybe Prelude.Text,
    -- | Specifies how to authenticate the user.
    ModifyUser -> Maybe AuthenticationMode
authenticationMode :: Prelude.Maybe AuthenticationMode,
    -- | Indicates no password is required for the user.
    ModifyUser -> Maybe Bool
noPasswordRequired :: Prelude.Maybe Prelude.Bool,
    -- | The passwords belonging to the user. You are allowed up to two.
    ModifyUser -> Maybe (NonEmpty Text)
passwords :: Prelude.Maybe (Prelude.NonEmpty Prelude.Text),
    -- | The ID of the user.
    ModifyUser -> Text
userId :: Prelude.Text
  }
  deriving (ModifyUser -> ModifyUser -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModifyUser -> ModifyUser -> Bool
$c/= :: ModifyUser -> ModifyUser -> Bool
== :: ModifyUser -> ModifyUser -> Bool
$c== :: ModifyUser -> ModifyUser -> Bool
Prelude.Eq, ReadPrec [ModifyUser]
ReadPrec ModifyUser
Int -> ReadS ModifyUser
ReadS [ModifyUser]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ModifyUser]
$creadListPrec :: ReadPrec [ModifyUser]
readPrec :: ReadPrec ModifyUser
$creadPrec :: ReadPrec ModifyUser
readList :: ReadS [ModifyUser]
$creadList :: ReadS [ModifyUser]
readsPrec :: Int -> ReadS ModifyUser
$creadsPrec :: Int -> ReadS ModifyUser
Prelude.Read, Int -> ModifyUser -> ShowS
[ModifyUser] -> ShowS
ModifyUser -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModifyUser] -> ShowS
$cshowList :: [ModifyUser] -> ShowS
show :: ModifyUser -> String
$cshow :: ModifyUser -> String
showsPrec :: Int -> ModifyUser -> ShowS
$cshowsPrec :: Int -> ModifyUser -> ShowS
Prelude.Show, forall x. Rep ModifyUser x -> ModifyUser
forall x. ModifyUser -> Rep ModifyUser x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ModifyUser x -> ModifyUser
$cfrom :: forall x. ModifyUser -> Rep ModifyUser x
Prelude.Generic)

-- |
-- Create a value of 'ModifyUser' 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:
--
-- 'accessString', 'modifyUser_accessString' - Access permissions string used for this user.
--
-- 'appendAccessString', 'modifyUser_appendAccessString' - Adds additional user permissions to the access string.
--
-- 'authenticationMode', 'modifyUser_authenticationMode' - Specifies how to authenticate the user.
--
-- 'noPasswordRequired', 'modifyUser_noPasswordRequired' - Indicates no password is required for the user.
--
-- 'passwords', 'modifyUser_passwords' - The passwords belonging to the user. You are allowed up to two.
--
-- 'userId', 'modifyUser_userId' - The ID of the user.
newModifyUser ::
  -- | 'userId'
  Prelude.Text ->
  ModifyUser
newModifyUser :: Text -> ModifyUser
newModifyUser Text
pUserId_ =
  ModifyUser'
    { $sel:accessString:ModifyUser' :: Maybe Text
accessString = forall a. Maybe a
Prelude.Nothing,
      $sel:appendAccessString:ModifyUser' :: Maybe Text
appendAccessString = forall a. Maybe a
Prelude.Nothing,
      $sel:authenticationMode:ModifyUser' :: Maybe AuthenticationMode
authenticationMode = forall a. Maybe a
Prelude.Nothing,
      $sel:noPasswordRequired:ModifyUser' :: Maybe Bool
noPasswordRequired = forall a. Maybe a
Prelude.Nothing,
      $sel:passwords:ModifyUser' :: Maybe (NonEmpty Text)
passwords = forall a. Maybe a
Prelude.Nothing,
      $sel:userId:ModifyUser' :: Text
userId = Text
pUserId_
    }

-- | Access permissions string used for this user.
modifyUser_accessString :: Lens.Lens' ModifyUser (Prelude.Maybe Prelude.Text)
modifyUser_accessString :: Lens' ModifyUser (Maybe Text)
modifyUser_accessString = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyUser' {Maybe Text
accessString :: Maybe Text
$sel:accessString:ModifyUser' :: ModifyUser -> Maybe Text
accessString} -> Maybe Text
accessString) (\s :: ModifyUser
s@ModifyUser' {} Maybe Text
a -> ModifyUser
s {$sel:accessString:ModifyUser' :: Maybe Text
accessString = Maybe Text
a} :: ModifyUser)

-- | Adds additional user permissions to the access string.
modifyUser_appendAccessString :: Lens.Lens' ModifyUser (Prelude.Maybe Prelude.Text)
modifyUser_appendAccessString :: Lens' ModifyUser (Maybe Text)
modifyUser_appendAccessString = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyUser' {Maybe Text
appendAccessString :: Maybe Text
$sel:appendAccessString:ModifyUser' :: ModifyUser -> Maybe Text
appendAccessString} -> Maybe Text
appendAccessString) (\s :: ModifyUser
s@ModifyUser' {} Maybe Text
a -> ModifyUser
s {$sel:appendAccessString:ModifyUser' :: Maybe Text
appendAccessString = Maybe Text
a} :: ModifyUser)

-- | Specifies how to authenticate the user.
modifyUser_authenticationMode :: Lens.Lens' ModifyUser (Prelude.Maybe AuthenticationMode)
modifyUser_authenticationMode :: Lens' ModifyUser (Maybe AuthenticationMode)
modifyUser_authenticationMode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyUser' {Maybe AuthenticationMode
authenticationMode :: Maybe AuthenticationMode
$sel:authenticationMode:ModifyUser' :: ModifyUser -> Maybe AuthenticationMode
authenticationMode} -> Maybe AuthenticationMode
authenticationMode) (\s :: ModifyUser
s@ModifyUser' {} Maybe AuthenticationMode
a -> ModifyUser
s {$sel:authenticationMode:ModifyUser' :: Maybe AuthenticationMode
authenticationMode = Maybe AuthenticationMode
a} :: ModifyUser)

-- | Indicates no password is required for the user.
modifyUser_noPasswordRequired :: Lens.Lens' ModifyUser (Prelude.Maybe Prelude.Bool)
modifyUser_noPasswordRequired :: Lens' ModifyUser (Maybe Bool)
modifyUser_noPasswordRequired = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyUser' {Maybe Bool
noPasswordRequired :: Maybe Bool
$sel:noPasswordRequired:ModifyUser' :: ModifyUser -> Maybe Bool
noPasswordRequired} -> Maybe Bool
noPasswordRequired) (\s :: ModifyUser
s@ModifyUser' {} Maybe Bool
a -> ModifyUser
s {$sel:noPasswordRequired:ModifyUser' :: Maybe Bool
noPasswordRequired = Maybe Bool
a} :: ModifyUser)

-- | The passwords belonging to the user. You are allowed up to two.
modifyUser_passwords :: Lens.Lens' ModifyUser (Prelude.Maybe (Prelude.NonEmpty Prelude.Text))
modifyUser_passwords :: Lens' ModifyUser (Maybe (NonEmpty Text))
modifyUser_passwords = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyUser' {Maybe (NonEmpty Text)
passwords :: Maybe (NonEmpty Text)
$sel:passwords:ModifyUser' :: ModifyUser -> Maybe (NonEmpty Text)
passwords} -> Maybe (NonEmpty Text)
passwords) (\s :: ModifyUser
s@ModifyUser' {} Maybe (NonEmpty Text)
a -> ModifyUser
s {$sel:passwords:ModifyUser' :: Maybe (NonEmpty Text)
passwords = Maybe (NonEmpty Text)
a} :: ModifyUser) 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

-- | The ID of the user.
modifyUser_userId :: Lens.Lens' ModifyUser Prelude.Text
modifyUser_userId :: Lens' ModifyUser Text
modifyUser_userId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyUser' {Text
userId :: Text
$sel:userId:ModifyUser' :: ModifyUser -> Text
userId} -> Text
userId) (\s :: ModifyUser
s@ModifyUser' {} Text
a -> ModifyUser
s {$sel:userId:ModifyUser' :: Text
userId = Text
a} :: ModifyUser)

instance Core.AWSRequest ModifyUser where
  type AWSResponse ModifyUser = User
  request :: (Service -> Service) -> ModifyUser -> Request ModifyUser
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ModifyUser
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ModifyUser)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
Text
-> (Int
    -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXMLWrapper
      Text
"ModifyUserResult"
      (\Int
s ResponseHeaders
h [Node]
x -> forall a. FromXML a => [Node] -> Either String a
Data.parseXML [Node]
x)

instance Prelude.Hashable ModifyUser where
  hashWithSalt :: Int -> ModifyUser -> Int
hashWithSalt Int
_salt ModifyUser' {Maybe Bool
Maybe (NonEmpty Text)
Maybe Text
Maybe AuthenticationMode
Text
userId :: Text
passwords :: Maybe (NonEmpty Text)
noPasswordRequired :: Maybe Bool
authenticationMode :: Maybe AuthenticationMode
appendAccessString :: Maybe Text
accessString :: Maybe Text
$sel:userId:ModifyUser' :: ModifyUser -> Text
$sel:passwords:ModifyUser' :: ModifyUser -> Maybe (NonEmpty Text)
$sel:noPasswordRequired:ModifyUser' :: ModifyUser -> Maybe Bool
$sel:authenticationMode:ModifyUser' :: ModifyUser -> Maybe AuthenticationMode
$sel:appendAccessString:ModifyUser' :: ModifyUser -> Maybe Text
$sel:accessString:ModifyUser' :: ModifyUser -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
accessString
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
appendAccessString
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AuthenticationMode
authenticationMode
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
noPasswordRequired
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Text)
passwords
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
userId

instance Prelude.NFData ModifyUser where
  rnf :: ModifyUser -> ()
rnf ModifyUser' {Maybe Bool
Maybe (NonEmpty Text)
Maybe Text
Maybe AuthenticationMode
Text
userId :: Text
passwords :: Maybe (NonEmpty Text)
noPasswordRequired :: Maybe Bool
authenticationMode :: Maybe AuthenticationMode
appendAccessString :: Maybe Text
accessString :: Maybe Text
$sel:userId:ModifyUser' :: ModifyUser -> Text
$sel:passwords:ModifyUser' :: ModifyUser -> Maybe (NonEmpty Text)
$sel:noPasswordRequired:ModifyUser' :: ModifyUser -> Maybe Bool
$sel:authenticationMode:ModifyUser' :: ModifyUser -> Maybe AuthenticationMode
$sel:appendAccessString:ModifyUser' :: ModifyUser -> Maybe Text
$sel:accessString:ModifyUser' :: ModifyUser -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
accessString
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
appendAccessString
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AuthenticationMode
authenticationMode
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
noPasswordRequired
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Text)
passwords
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
userId

instance Data.ToHeaders ModifyUser where
  toHeaders :: ModifyUser -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

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

instance Data.ToQuery ModifyUser where
  toQuery :: ModifyUser -> QueryString
toQuery ModifyUser' {Maybe Bool
Maybe (NonEmpty Text)
Maybe Text
Maybe AuthenticationMode
Text
userId :: Text
passwords :: Maybe (NonEmpty Text)
noPasswordRequired :: Maybe Bool
authenticationMode :: Maybe AuthenticationMode
appendAccessString :: Maybe Text
accessString :: Maybe Text
$sel:userId:ModifyUser' :: ModifyUser -> Text
$sel:passwords:ModifyUser' :: ModifyUser -> Maybe (NonEmpty Text)
$sel:noPasswordRequired:ModifyUser' :: ModifyUser -> Maybe Bool
$sel:authenticationMode:ModifyUser' :: ModifyUser -> Maybe AuthenticationMode
$sel:appendAccessString:ModifyUser' :: ModifyUser -> Maybe Text
$sel:accessString:ModifyUser' :: ModifyUser -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"ModifyUser" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2015-02-02" :: Prelude.ByteString),
        ByteString
"AccessString" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
accessString,
        ByteString
"AppendAccessString" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
appendAccessString,
        ByteString
"AuthenticationMode" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe AuthenticationMode
authenticationMode,
        ByteString
"NoPasswordRequired" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
noPasswordRequired,
        ByteString
"Passwords"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: forall a. ToQuery a => a -> QueryString
Data.toQuery
            (forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"member" forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (NonEmpty Text)
passwords),
        ByteString
"UserId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
userId
      ]