{-# 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.StorageGateway.UpdateSMBLocalGroups
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Updates the list of Active Directory users and groups that have special
-- permissions for SMB file shares on the gateway.
module Amazonka.StorageGateway.UpdateSMBLocalGroups
  ( -- * Creating a Request
    UpdateSMBLocalGroups (..),
    newUpdateSMBLocalGroups,

    -- * Request Lenses
    updateSMBLocalGroups_gatewayARN,
    updateSMBLocalGroups_sMBLocalGroups,

    -- * Destructuring the Response
    UpdateSMBLocalGroupsResponse (..),
    newUpdateSMBLocalGroupsResponse,

    -- * Response Lenses
    updateSMBLocalGroupsResponse_gatewayARN,
    updateSMBLocalGroupsResponse_httpStatus,
  )
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 qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response
import Amazonka.StorageGateway.Types

-- | /See:/ 'newUpdateSMBLocalGroups' smart constructor.
data UpdateSMBLocalGroups = UpdateSMBLocalGroups'
  { UpdateSMBLocalGroups -> Text
gatewayARN :: Prelude.Text,
    -- | A list of Active Directory users and groups that you want to grant
    -- special permissions for SMB file shares on the gateway.
    UpdateSMBLocalGroups -> SMBLocalGroups
sMBLocalGroups :: SMBLocalGroups
  }
  deriving (UpdateSMBLocalGroups -> UpdateSMBLocalGroups -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateSMBLocalGroups -> UpdateSMBLocalGroups -> Bool
$c/= :: UpdateSMBLocalGroups -> UpdateSMBLocalGroups -> Bool
== :: UpdateSMBLocalGroups -> UpdateSMBLocalGroups -> Bool
$c== :: UpdateSMBLocalGroups -> UpdateSMBLocalGroups -> Bool
Prelude.Eq, ReadPrec [UpdateSMBLocalGroups]
ReadPrec UpdateSMBLocalGroups
Int -> ReadS UpdateSMBLocalGroups
ReadS [UpdateSMBLocalGroups]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateSMBLocalGroups]
$creadListPrec :: ReadPrec [UpdateSMBLocalGroups]
readPrec :: ReadPrec UpdateSMBLocalGroups
$creadPrec :: ReadPrec UpdateSMBLocalGroups
readList :: ReadS [UpdateSMBLocalGroups]
$creadList :: ReadS [UpdateSMBLocalGroups]
readsPrec :: Int -> ReadS UpdateSMBLocalGroups
$creadsPrec :: Int -> ReadS UpdateSMBLocalGroups
Prelude.Read, Int -> UpdateSMBLocalGroups -> ShowS
[UpdateSMBLocalGroups] -> ShowS
UpdateSMBLocalGroups -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateSMBLocalGroups] -> ShowS
$cshowList :: [UpdateSMBLocalGroups] -> ShowS
show :: UpdateSMBLocalGroups -> String
$cshow :: UpdateSMBLocalGroups -> String
showsPrec :: Int -> UpdateSMBLocalGroups -> ShowS
$cshowsPrec :: Int -> UpdateSMBLocalGroups -> ShowS
Prelude.Show, forall x. Rep UpdateSMBLocalGroups x -> UpdateSMBLocalGroups
forall x. UpdateSMBLocalGroups -> Rep UpdateSMBLocalGroups x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateSMBLocalGroups x -> UpdateSMBLocalGroups
$cfrom :: forall x. UpdateSMBLocalGroups -> Rep UpdateSMBLocalGroups x
Prelude.Generic)

-- |
-- Create a value of 'UpdateSMBLocalGroups' 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:
--
-- 'gatewayARN', 'updateSMBLocalGroups_gatewayARN' - Undocumented member.
--
-- 'sMBLocalGroups', 'updateSMBLocalGroups_sMBLocalGroups' - A list of Active Directory users and groups that you want to grant
-- special permissions for SMB file shares on the gateway.
newUpdateSMBLocalGroups ::
  -- | 'gatewayARN'
  Prelude.Text ->
  -- | 'sMBLocalGroups'
  SMBLocalGroups ->
  UpdateSMBLocalGroups
newUpdateSMBLocalGroups :: Text -> SMBLocalGroups -> UpdateSMBLocalGroups
newUpdateSMBLocalGroups Text
pGatewayARN_ SMBLocalGroups
pSMBLocalGroups_ =
  UpdateSMBLocalGroups'
    { $sel:gatewayARN:UpdateSMBLocalGroups' :: Text
gatewayARN = Text
pGatewayARN_,
      $sel:sMBLocalGroups:UpdateSMBLocalGroups' :: SMBLocalGroups
sMBLocalGroups = SMBLocalGroups
pSMBLocalGroups_
    }

-- | Undocumented member.
updateSMBLocalGroups_gatewayARN :: Lens.Lens' UpdateSMBLocalGroups Prelude.Text
updateSMBLocalGroups_gatewayARN :: Lens' UpdateSMBLocalGroups Text
updateSMBLocalGroups_gatewayARN = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateSMBLocalGroups' {Text
gatewayARN :: Text
$sel:gatewayARN:UpdateSMBLocalGroups' :: UpdateSMBLocalGroups -> Text
gatewayARN} -> Text
gatewayARN) (\s :: UpdateSMBLocalGroups
s@UpdateSMBLocalGroups' {} Text
a -> UpdateSMBLocalGroups
s {$sel:gatewayARN:UpdateSMBLocalGroups' :: Text
gatewayARN = Text
a} :: UpdateSMBLocalGroups)

-- | A list of Active Directory users and groups that you want to grant
-- special permissions for SMB file shares on the gateway.
updateSMBLocalGroups_sMBLocalGroups :: Lens.Lens' UpdateSMBLocalGroups SMBLocalGroups
updateSMBLocalGroups_sMBLocalGroups :: Lens' UpdateSMBLocalGroups SMBLocalGroups
updateSMBLocalGroups_sMBLocalGroups = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateSMBLocalGroups' {SMBLocalGroups
sMBLocalGroups :: SMBLocalGroups
$sel:sMBLocalGroups:UpdateSMBLocalGroups' :: UpdateSMBLocalGroups -> SMBLocalGroups
sMBLocalGroups} -> SMBLocalGroups
sMBLocalGroups) (\s :: UpdateSMBLocalGroups
s@UpdateSMBLocalGroups' {} SMBLocalGroups
a -> UpdateSMBLocalGroups
s {$sel:sMBLocalGroups:UpdateSMBLocalGroups' :: SMBLocalGroups
sMBLocalGroups = SMBLocalGroups
a} :: UpdateSMBLocalGroups)

instance Core.AWSRequest UpdateSMBLocalGroups where
  type
    AWSResponse UpdateSMBLocalGroups =
      UpdateSMBLocalGroupsResponse
  request :: (Service -> Service)
-> UpdateSMBLocalGroups -> Request UpdateSMBLocalGroups
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 UpdateSMBLocalGroups
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse UpdateSMBLocalGroups)))
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 Text -> Int -> UpdateSMBLocalGroupsResponse
UpdateSMBLocalGroupsResponse'
            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
"GatewayARN")
            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 UpdateSMBLocalGroups where
  hashWithSalt :: Int -> UpdateSMBLocalGroups -> Int
hashWithSalt Int
_salt UpdateSMBLocalGroups' {Text
SMBLocalGroups
sMBLocalGroups :: SMBLocalGroups
gatewayARN :: Text
$sel:sMBLocalGroups:UpdateSMBLocalGroups' :: UpdateSMBLocalGroups -> SMBLocalGroups
$sel:gatewayARN:UpdateSMBLocalGroups' :: UpdateSMBLocalGroups -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
gatewayARN
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` SMBLocalGroups
sMBLocalGroups

instance Prelude.NFData UpdateSMBLocalGroups where
  rnf :: UpdateSMBLocalGroups -> ()
rnf UpdateSMBLocalGroups' {Text
SMBLocalGroups
sMBLocalGroups :: SMBLocalGroups
gatewayARN :: Text
$sel:sMBLocalGroups:UpdateSMBLocalGroups' :: UpdateSMBLocalGroups -> SMBLocalGroups
$sel:gatewayARN:UpdateSMBLocalGroups' :: UpdateSMBLocalGroups -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
gatewayARN
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf SMBLocalGroups
sMBLocalGroups

instance Data.ToHeaders UpdateSMBLocalGroups where
  toHeaders :: UpdateSMBLocalGroups -> 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
"StorageGateway_20130630.UpdateSMBLocalGroups" ::
                          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 UpdateSMBLocalGroups where
  toJSON :: UpdateSMBLocalGroups -> Value
toJSON UpdateSMBLocalGroups' {Text
SMBLocalGroups
sMBLocalGroups :: SMBLocalGroups
gatewayARN :: Text
$sel:sMBLocalGroups:UpdateSMBLocalGroups' :: UpdateSMBLocalGroups -> SMBLocalGroups
$sel:gatewayARN:UpdateSMBLocalGroups' :: UpdateSMBLocalGroups -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just (Key
"GatewayARN" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
gatewayARN),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"SMBLocalGroups" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= SMBLocalGroups
sMBLocalGroups)
          ]
      )

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

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

-- | /See:/ 'newUpdateSMBLocalGroupsResponse' smart constructor.
data UpdateSMBLocalGroupsResponse = UpdateSMBLocalGroupsResponse'
  { UpdateSMBLocalGroupsResponse -> Maybe Text
gatewayARN :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    UpdateSMBLocalGroupsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (UpdateSMBLocalGroupsResponse
-> UpdateSMBLocalGroupsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateSMBLocalGroupsResponse
-> UpdateSMBLocalGroupsResponse -> Bool
$c/= :: UpdateSMBLocalGroupsResponse
-> UpdateSMBLocalGroupsResponse -> Bool
== :: UpdateSMBLocalGroupsResponse
-> UpdateSMBLocalGroupsResponse -> Bool
$c== :: UpdateSMBLocalGroupsResponse
-> UpdateSMBLocalGroupsResponse -> Bool
Prelude.Eq, ReadPrec [UpdateSMBLocalGroupsResponse]
ReadPrec UpdateSMBLocalGroupsResponse
Int -> ReadS UpdateSMBLocalGroupsResponse
ReadS [UpdateSMBLocalGroupsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateSMBLocalGroupsResponse]
$creadListPrec :: ReadPrec [UpdateSMBLocalGroupsResponse]
readPrec :: ReadPrec UpdateSMBLocalGroupsResponse
$creadPrec :: ReadPrec UpdateSMBLocalGroupsResponse
readList :: ReadS [UpdateSMBLocalGroupsResponse]
$creadList :: ReadS [UpdateSMBLocalGroupsResponse]
readsPrec :: Int -> ReadS UpdateSMBLocalGroupsResponse
$creadsPrec :: Int -> ReadS UpdateSMBLocalGroupsResponse
Prelude.Read, Int -> UpdateSMBLocalGroupsResponse -> ShowS
[UpdateSMBLocalGroupsResponse] -> ShowS
UpdateSMBLocalGroupsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateSMBLocalGroupsResponse] -> ShowS
$cshowList :: [UpdateSMBLocalGroupsResponse] -> ShowS
show :: UpdateSMBLocalGroupsResponse -> String
$cshow :: UpdateSMBLocalGroupsResponse -> String
showsPrec :: Int -> UpdateSMBLocalGroupsResponse -> ShowS
$cshowsPrec :: Int -> UpdateSMBLocalGroupsResponse -> ShowS
Prelude.Show, forall x.
Rep UpdateSMBLocalGroupsResponse x -> UpdateSMBLocalGroupsResponse
forall x.
UpdateSMBLocalGroupsResponse -> Rep UpdateSMBLocalGroupsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep UpdateSMBLocalGroupsResponse x -> UpdateSMBLocalGroupsResponse
$cfrom :: forall x.
UpdateSMBLocalGroupsResponse -> Rep UpdateSMBLocalGroupsResponse x
Prelude.Generic)

-- |
-- Create a value of 'UpdateSMBLocalGroupsResponse' 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:
--
-- 'gatewayARN', 'updateSMBLocalGroupsResponse_gatewayARN' - Undocumented member.
--
-- 'httpStatus', 'updateSMBLocalGroupsResponse_httpStatus' - The response's http status code.
newUpdateSMBLocalGroupsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdateSMBLocalGroupsResponse
newUpdateSMBLocalGroupsResponse :: Int -> UpdateSMBLocalGroupsResponse
newUpdateSMBLocalGroupsResponse Int
pHttpStatus_ =
  UpdateSMBLocalGroupsResponse'
    { $sel:gatewayARN:UpdateSMBLocalGroupsResponse' :: Maybe Text
gatewayARN =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:UpdateSMBLocalGroupsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Undocumented member.
updateSMBLocalGroupsResponse_gatewayARN :: Lens.Lens' UpdateSMBLocalGroupsResponse (Prelude.Maybe Prelude.Text)
updateSMBLocalGroupsResponse_gatewayARN :: Lens' UpdateSMBLocalGroupsResponse (Maybe Text)
updateSMBLocalGroupsResponse_gatewayARN = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateSMBLocalGroupsResponse' {Maybe Text
gatewayARN :: Maybe Text
$sel:gatewayARN:UpdateSMBLocalGroupsResponse' :: UpdateSMBLocalGroupsResponse -> Maybe Text
gatewayARN} -> Maybe Text
gatewayARN) (\s :: UpdateSMBLocalGroupsResponse
s@UpdateSMBLocalGroupsResponse' {} Maybe Text
a -> UpdateSMBLocalGroupsResponse
s {$sel:gatewayARN:UpdateSMBLocalGroupsResponse' :: Maybe Text
gatewayARN = Maybe Text
a} :: UpdateSMBLocalGroupsResponse)

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

instance Prelude.NFData UpdateSMBLocalGroupsResponse where
  rnf :: UpdateSMBLocalGroupsResponse -> ()
rnf UpdateSMBLocalGroupsResponse' {Int
Maybe Text
httpStatus :: Int
gatewayARN :: Maybe Text
$sel:httpStatus:UpdateSMBLocalGroupsResponse' :: UpdateSMBLocalGroupsResponse -> Int
$sel:gatewayARN:UpdateSMBLocalGroupsResponse' :: UpdateSMBLocalGroupsResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
gatewayARN
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus