{-# 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.Redshift.PurchaseReservedNodeOffering
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Allows you to purchase reserved nodes. Amazon Redshift offers a
-- predefined set of reserved node offerings. You can purchase one or more
-- of the offerings. You can call the DescribeReservedNodeOfferings API to
-- obtain the available reserved node offerings. You can call this API by
-- providing a specific reserved node offering and the number of nodes you
-- want to reserve.
--
-- For more information about reserved node offerings, go to
-- <https://docs.aws.amazon.com/redshift/latest/mgmt/purchase-reserved-node-instance.html Purchasing Reserved Nodes>
-- in the /Amazon Redshift Cluster Management Guide/.
module Amazonka.Redshift.PurchaseReservedNodeOffering
  ( -- * Creating a Request
    PurchaseReservedNodeOffering (..),
    newPurchaseReservedNodeOffering,

    -- * Request Lenses
    purchaseReservedNodeOffering_nodeCount,
    purchaseReservedNodeOffering_reservedNodeOfferingId,

    -- * Destructuring the Response
    PurchaseReservedNodeOfferingResponse (..),
    newPurchaseReservedNodeOfferingResponse,

    -- * Response Lenses
    purchaseReservedNodeOfferingResponse_reservedNode,
    purchaseReservedNodeOfferingResponse_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 Amazonka.Redshift.Types
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- |
--
-- /See:/ 'newPurchaseReservedNodeOffering' smart constructor.
data PurchaseReservedNodeOffering = PurchaseReservedNodeOffering'
  { -- | The number of reserved nodes that you want to purchase.
    --
    -- Default: @1@
    PurchaseReservedNodeOffering -> Maybe Int
nodeCount :: Prelude.Maybe Prelude.Int,
    -- | The unique identifier of the reserved node offering you want to
    -- purchase.
    PurchaseReservedNodeOffering -> Text
reservedNodeOfferingId :: Prelude.Text
  }
  deriving (PurchaseReservedNodeOffering
-> PurchaseReservedNodeOffering -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PurchaseReservedNodeOffering
-> PurchaseReservedNodeOffering -> Bool
$c/= :: PurchaseReservedNodeOffering
-> PurchaseReservedNodeOffering -> Bool
== :: PurchaseReservedNodeOffering
-> PurchaseReservedNodeOffering -> Bool
$c== :: PurchaseReservedNodeOffering
-> PurchaseReservedNodeOffering -> Bool
Prelude.Eq, ReadPrec [PurchaseReservedNodeOffering]
ReadPrec PurchaseReservedNodeOffering
Int -> ReadS PurchaseReservedNodeOffering
ReadS [PurchaseReservedNodeOffering]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PurchaseReservedNodeOffering]
$creadListPrec :: ReadPrec [PurchaseReservedNodeOffering]
readPrec :: ReadPrec PurchaseReservedNodeOffering
$creadPrec :: ReadPrec PurchaseReservedNodeOffering
readList :: ReadS [PurchaseReservedNodeOffering]
$creadList :: ReadS [PurchaseReservedNodeOffering]
readsPrec :: Int -> ReadS PurchaseReservedNodeOffering
$creadsPrec :: Int -> ReadS PurchaseReservedNodeOffering
Prelude.Read, Int -> PurchaseReservedNodeOffering -> ShowS
[PurchaseReservedNodeOffering] -> ShowS
PurchaseReservedNodeOffering -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PurchaseReservedNodeOffering] -> ShowS
$cshowList :: [PurchaseReservedNodeOffering] -> ShowS
show :: PurchaseReservedNodeOffering -> String
$cshow :: PurchaseReservedNodeOffering -> String
showsPrec :: Int -> PurchaseReservedNodeOffering -> ShowS
$cshowsPrec :: Int -> PurchaseReservedNodeOffering -> ShowS
Prelude.Show, forall x.
Rep PurchaseReservedNodeOffering x -> PurchaseReservedNodeOffering
forall x.
PurchaseReservedNodeOffering -> Rep PurchaseReservedNodeOffering x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep PurchaseReservedNodeOffering x -> PurchaseReservedNodeOffering
$cfrom :: forall x.
PurchaseReservedNodeOffering -> Rep PurchaseReservedNodeOffering x
Prelude.Generic)

-- |
-- Create a value of 'PurchaseReservedNodeOffering' 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:
--
-- 'nodeCount', 'purchaseReservedNodeOffering_nodeCount' - The number of reserved nodes that you want to purchase.
--
-- Default: @1@
--
-- 'reservedNodeOfferingId', 'purchaseReservedNodeOffering_reservedNodeOfferingId' - The unique identifier of the reserved node offering you want to
-- purchase.
newPurchaseReservedNodeOffering ::
  -- | 'reservedNodeOfferingId'
  Prelude.Text ->
  PurchaseReservedNodeOffering
newPurchaseReservedNodeOffering :: Text -> PurchaseReservedNodeOffering
newPurchaseReservedNodeOffering
  Text
pReservedNodeOfferingId_ =
    PurchaseReservedNodeOffering'
      { $sel:nodeCount:PurchaseReservedNodeOffering' :: Maybe Int
nodeCount =
          forall a. Maybe a
Prelude.Nothing,
        $sel:reservedNodeOfferingId:PurchaseReservedNodeOffering' :: Text
reservedNodeOfferingId =
          Text
pReservedNodeOfferingId_
      }

-- | The number of reserved nodes that you want to purchase.
--
-- Default: @1@
purchaseReservedNodeOffering_nodeCount :: Lens.Lens' PurchaseReservedNodeOffering (Prelude.Maybe Prelude.Int)
purchaseReservedNodeOffering_nodeCount :: Lens' PurchaseReservedNodeOffering (Maybe Int)
purchaseReservedNodeOffering_nodeCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PurchaseReservedNodeOffering' {Maybe Int
nodeCount :: Maybe Int
$sel:nodeCount:PurchaseReservedNodeOffering' :: PurchaseReservedNodeOffering -> Maybe Int
nodeCount} -> Maybe Int
nodeCount) (\s :: PurchaseReservedNodeOffering
s@PurchaseReservedNodeOffering' {} Maybe Int
a -> PurchaseReservedNodeOffering
s {$sel:nodeCount:PurchaseReservedNodeOffering' :: Maybe Int
nodeCount = Maybe Int
a} :: PurchaseReservedNodeOffering)

-- | The unique identifier of the reserved node offering you want to
-- purchase.
purchaseReservedNodeOffering_reservedNodeOfferingId :: Lens.Lens' PurchaseReservedNodeOffering Prelude.Text
purchaseReservedNodeOffering_reservedNodeOfferingId :: Lens' PurchaseReservedNodeOffering Text
purchaseReservedNodeOffering_reservedNodeOfferingId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PurchaseReservedNodeOffering' {Text
reservedNodeOfferingId :: Text
$sel:reservedNodeOfferingId:PurchaseReservedNodeOffering' :: PurchaseReservedNodeOffering -> Text
reservedNodeOfferingId} -> Text
reservedNodeOfferingId) (\s :: PurchaseReservedNodeOffering
s@PurchaseReservedNodeOffering' {} Text
a -> PurchaseReservedNodeOffering
s {$sel:reservedNodeOfferingId:PurchaseReservedNodeOffering' :: Text
reservedNodeOfferingId = Text
a} :: PurchaseReservedNodeOffering)

instance Core.AWSRequest PurchaseReservedNodeOffering where
  type
    AWSResponse PurchaseReservedNodeOffering =
      PurchaseReservedNodeOfferingResponse
  request :: (Service -> Service)
-> PurchaseReservedNodeOffering
-> Request PurchaseReservedNodeOffering
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 PurchaseReservedNodeOffering
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse PurchaseReservedNodeOffering)))
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
"PurchaseReservedNodeOfferingResult"
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe ReservedNode -> Int -> PurchaseReservedNodeOfferingResponse
PurchaseReservedNodeOfferingResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ReservedNode")
            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
    PurchaseReservedNodeOffering
  where
  hashWithSalt :: Int -> PurchaseReservedNodeOffering -> Int
hashWithSalt Int
_salt PurchaseReservedNodeOffering' {Maybe Int
Text
reservedNodeOfferingId :: Text
nodeCount :: Maybe Int
$sel:reservedNodeOfferingId:PurchaseReservedNodeOffering' :: PurchaseReservedNodeOffering -> Text
$sel:nodeCount:PurchaseReservedNodeOffering' :: PurchaseReservedNodeOffering -> Maybe Int
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
nodeCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
reservedNodeOfferingId

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

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

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

instance Data.ToQuery PurchaseReservedNodeOffering where
  toQuery :: PurchaseReservedNodeOffering -> QueryString
toQuery PurchaseReservedNodeOffering' {Maybe Int
Text
reservedNodeOfferingId :: Text
nodeCount :: Maybe Int
$sel:reservedNodeOfferingId:PurchaseReservedNodeOffering' :: PurchaseReservedNodeOffering -> Text
$sel:nodeCount:PurchaseReservedNodeOffering' :: PurchaseReservedNodeOffering -> Maybe Int
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: ( ByteString
"PurchaseReservedNodeOffering" ::
                      Prelude.ByteString
                  ),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2012-12-01" :: Prelude.ByteString),
        ByteString
"NodeCount" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Int
nodeCount,
        ByteString
"ReservedNodeOfferingId"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
reservedNodeOfferingId
      ]

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

-- |
-- Create a value of 'PurchaseReservedNodeOfferingResponse' 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:
--
-- 'reservedNode', 'purchaseReservedNodeOfferingResponse_reservedNode' - Undocumented member.
--
-- 'httpStatus', 'purchaseReservedNodeOfferingResponse_httpStatus' - The response's http status code.
newPurchaseReservedNodeOfferingResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  PurchaseReservedNodeOfferingResponse
newPurchaseReservedNodeOfferingResponse :: Int -> PurchaseReservedNodeOfferingResponse
newPurchaseReservedNodeOfferingResponse Int
pHttpStatus_ =
  PurchaseReservedNodeOfferingResponse'
    { $sel:reservedNode:PurchaseReservedNodeOfferingResponse' :: Maybe ReservedNode
reservedNode =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:PurchaseReservedNodeOfferingResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Undocumented member.
purchaseReservedNodeOfferingResponse_reservedNode :: Lens.Lens' PurchaseReservedNodeOfferingResponse (Prelude.Maybe ReservedNode)
purchaseReservedNodeOfferingResponse_reservedNode :: Lens' PurchaseReservedNodeOfferingResponse (Maybe ReservedNode)
purchaseReservedNodeOfferingResponse_reservedNode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PurchaseReservedNodeOfferingResponse' {Maybe ReservedNode
reservedNode :: Maybe ReservedNode
$sel:reservedNode:PurchaseReservedNodeOfferingResponse' :: PurchaseReservedNodeOfferingResponse -> Maybe ReservedNode
reservedNode} -> Maybe ReservedNode
reservedNode) (\s :: PurchaseReservedNodeOfferingResponse
s@PurchaseReservedNodeOfferingResponse' {} Maybe ReservedNode
a -> PurchaseReservedNodeOfferingResponse
s {$sel:reservedNode:PurchaseReservedNodeOfferingResponse' :: Maybe ReservedNode
reservedNode = Maybe ReservedNode
a} :: PurchaseReservedNodeOfferingResponse)

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

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