{-# 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.LakeFormation.ExtendTransaction
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Indicates to the service that the specified transaction is still active
-- and should not be treated as idle and aborted.
--
-- Write transactions that remain idle for a long period are automatically
-- aborted unless explicitly extended.
module Amazonka.LakeFormation.ExtendTransaction
  ( -- * Creating a Request
    ExtendTransaction (..),
    newExtendTransaction,

    -- * Request Lenses
    extendTransaction_transactionId,

    -- * Destructuring the Response
    ExtendTransactionResponse (..),
    newExtendTransactionResponse,

    -- * Response Lenses
    extendTransactionResponse_httpStatus,
  )
where

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

-- | /See:/ 'newExtendTransaction' smart constructor.
data ExtendTransaction = ExtendTransaction'
  { -- | The transaction to extend.
    ExtendTransaction -> Maybe Text
transactionId :: Prelude.Maybe Prelude.Text
  }
  deriving (ExtendTransaction -> ExtendTransaction -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExtendTransaction -> ExtendTransaction -> Bool
$c/= :: ExtendTransaction -> ExtendTransaction -> Bool
== :: ExtendTransaction -> ExtendTransaction -> Bool
$c== :: ExtendTransaction -> ExtendTransaction -> Bool
Prelude.Eq, ReadPrec [ExtendTransaction]
ReadPrec ExtendTransaction
Int -> ReadS ExtendTransaction
ReadS [ExtendTransaction]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ExtendTransaction]
$creadListPrec :: ReadPrec [ExtendTransaction]
readPrec :: ReadPrec ExtendTransaction
$creadPrec :: ReadPrec ExtendTransaction
readList :: ReadS [ExtendTransaction]
$creadList :: ReadS [ExtendTransaction]
readsPrec :: Int -> ReadS ExtendTransaction
$creadsPrec :: Int -> ReadS ExtendTransaction
Prelude.Read, Int -> ExtendTransaction -> ShowS
[ExtendTransaction] -> ShowS
ExtendTransaction -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExtendTransaction] -> ShowS
$cshowList :: [ExtendTransaction] -> ShowS
show :: ExtendTransaction -> String
$cshow :: ExtendTransaction -> String
showsPrec :: Int -> ExtendTransaction -> ShowS
$cshowsPrec :: Int -> ExtendTransaction -> ShowS
Prelude.Show, forall x. Rep ExtendTransaction x -> ExtendTransaction
forall x. ExtendTransaction -> Rep ExtendTransaction x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ExtendTransaction x -> ExtendTransaction
$cfrom :: forall x. ExtendTransaction -> Rep ExtendTransaction x
Prelude.Generic)

-- |
-- Create a value of 'ExtendTransaction' 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:
--
-- 'transactionId', 'extendTransaction_transactionId' - The transaction to extend.
newExtendTransaction ::
  ExtendTransaction
newExtendTransaction :: ExtendTransaction
newExtendTransaction =
  ExtendTransaction' {$sel:transactionId:ExtendTransaction' :: Maybe Text
transactionId = forall a. Maybe a
Prelude.Nothing}

-- | The transaction to extend.
extendTransaction_transactionId :: Lens.Lens' ExtendTransaction (Prelude.Maybe Prelude.Text)
extendTransaction_transactionId :: Lens' ExtendTransaction (Maybe Text)
extendTransaction_transactionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExtendTransaction' {Maybe Text
transactionId :: Maybe Text
$sel:transactionId:ExtendTransaction' :: ExtendTransaction -> Maybe Text
transactionId} -> Maybe Text
transactionId) (\s :: ExtendTransaction
s@ExtendTransaction' {} Maybe Text
a -> ExtendTransaction
s {$sel:transactionId:ExtendTransaction' :: Maybe Text
transactionId = Maybe Text
a} :: ExtendTransaction)

instance Core.AWSRequest ExtendTransaction where
  type
    AWSResponse ExtendTransaction =
      ExtendTransactionResponse
  request :: (Service -> Service)
-> ExtendTransaction -> Request ExtendTransaction
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 ExtendTransaction
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ExtendTransaction)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> ExtendTransactionResponse
ExtendTransactionResponse'
            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))
      )

instance Prelude.Hashable ExtendTransaction where
  hashWithSalt :: Int -> ExtendTransaction -> Int
hashWithSalt Int
_salt ExtendTransaction' {Maybe Text
transactionId :: Maybe Text
$sel:transactionId:ExtendTransaction' :: ExtendTransaction -> Maybe Text
..} =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
transactionId

instance Prelude.NFData ExtendTransaction where
  rnf :: ExtendTransaction -> ()
rnf ExtendTransaction' {Maybe Text
transactionId :: Maybe Text
$sel:transactionId:ExtendTransaction' :: ExtendTransaction -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
transactionId

instance Data.ToHeaders ExtendTransaction where
  toHeaders :: ExtendTransaction -> 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.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON ExtendTransaction where
  toJSON :: ExtendTransaction -> Value
toJSON ExtendTransaction' {Maybe Text
transactionId :: Maybe Text
$sel:transactionId:ExtendTransaction' :: ExtendTransaction -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"TransactionId" 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 Text
transactionId
          ]
      )

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

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

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

-- |
-- Create a value of 'ExtendTransactionResponse' 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', 'extendTransactionResponse_httpStatus' - The response's http status code.
newExtendTransactionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ExtendTransactionResponse
newExtendTransactionResponse :: Int -> ExtendTransactionResponse
newExtendTransactionResponse Int
pHttpStatus_ =
  ExtendTransactionResponse'
    { $sel:httpStatus:ExtendTransactionResponse' :: Int
httpStatus =
        Int
pHttpStatus_
    }

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

instance Prelude.NFData ExtendTransactionResponse where
  rnf :: ExtendTransactionResponse -> ()
rnf ExtendTransactionResponse' {Int
httpStatus :: Int
$sel:httpStatus:ExtendTransactionResponse' :: ExtendTransactionResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus